Rosetta 3.4
Namespaces | Classes | Typedefs | Functions | Variables
core::kinematics Namespace Reference

See AtomTree overview and FoldTree overview for details. More...

Namespaces

namespace  tree

Classes

class  AtomTree
 The AtomTree class is a wrapper for a tree of kinematic Atoms. More...
class  AtomWithDOFChange
 simple class for use in output-sensitive refold subroutine. More...
class  Edge
 single edge of the fold_tree More...
class  EXCN_InvalidFoldTree
class  FoldTree
 The FoldTree is a residue-based treelike representation of a molecule. More...
class  Jump
 an object which makes rigid-body transformation with translational and rotational perturbation More...
class  MinimizerMapBase
class  MoveMap
 A class specifying DOFs to be flexible or fixed. More...
class  ResidueCoordinateChangeList
 The AtomTree is responsible for informing the conformation of which residues have had either internal (DOF) or external (xyz) coordinate changes so that the Conformation may shuttle O(k) -- output sensitive -- data from the AtomTree to the Residue objects it manages. More...
class  RT
 Rotation + translation class. More...
class  ShortestPathInFoldTree
class  Stub
 Stub class -- an object of orthogonal coordinate frame. More...

Typedefs

typedef id::AtomID_Map
< tree::AtomOP
AtomPointer2D
typedef utility::vector1
< tree::AtomOP
AtomPointer1D
typedef
utility::pointer::access_ptr
< AtomTree
AtomTreeAP
typedef
utility::pointer::access_ptr
< AtomTree const > 
AtomTreeCAP
typedef
utility::pointer::owning_ptr
< AtomTree
AtomTreeOP
typedef
utility::pointer::owning_ptr
< AtomTree const > 
AtomTreeCOP
typedef utility::vector1
< AtomWithDOFChange
AtomDOFChangeSet
typedef ObjexxFCL::FArray1D_int DomainMap
typedef
utility::pointer::access_ptr
< Edge
EdgeAP
typedef
utility::pointer::owning_ptr
< Edge
EdgeOP
typedef
utility::pointer::access_ptr
< FoldTree
FoldTreeAP
typedef
utility::pointer::access_ptr
< FoldTree const > 
FoldTreeCAP
typedef
utility::pointer::owning_ptr
< FoldTree
FoldTreeOP
typedef
utility::pointer::owning_ptr
< FoldTree const > 
FoldTreeCOP
typedef
utility::pointer::owning_ptr
< MinimizerMapBase
MinimizerMapBaseOP
typedef
utility::pointer::owning_ptr
< MinimizerMapBase const > 
MinimizerMapBaseCOP
typedef
utility::pointer::owning_ptr
< MoveMap
MoveMapOP
typedef
utility::pointer::owning_ptr
< MoveMap const > 
MoveMapCOP
typedef
utility::pointer::owning_ptr
< ResidueCoordinateChangeList
ResidueCoordinateChangeListOP
typedef utility::vector1< SizeResidueIndexList
typedef utility::vector1< Size >
::const_iterator 
ResidueListIterator
typedef
utility::pointer::access_ptr
< RT
RTAP
typedef
utility::pointer::owning_ptr
< RT
RTOP
typedef
utility::pointer::access_ptr
< ShortestPathInFoldTree
ShortestPathInFoldTreeAP
typedef
utility::pointer::owning_ptr
< ShortestPathInFoldTree
ShortestPathInFoldTreeOP
typedef
utility::pointer::owning_ptr
< ShortestPathInFoldTree const > 
ShortestPathInFoldTreeCOP
typedef utility::vector1
< utility::vector1< Size > > 
Links

Functions

static basic::Tracer TR ("core.kinematics.AtomTree")
void find_stub_transform (Stub const &stub1, Stub const &stub2, RT const &rt, Stub::Matrix &A, Vector &b)
int const dir_jump (0)
static basic::Tracer tr ("core.kinematics")
std::ostream & operator<< (std::ostream &os, const Edge &e)
std::istream & operator>> (std::istream &is, Edge &e)
bool operator< (Edge const &a, Edge const &b)
bool operator== (Edge const &a, Edge const &b)
bool operator!= (Edge const &a, Edge const &b)
bool operator== (FoldTree const &a, FoldTree const &b)
bool operator!= (const FoldTree &a, const FoldTree &b)
std::ostream & operator<< (std::ostream &os, FoldTree const &t)
std::istream & operator>> (std::istream &is, FoldTree &t)
static
numeric::random::RandomGenerator 
jump_RG (62454)
std::istream & operator>> (std::istream &is, Jump &jump)
std::ostream & operator<< (std::ostream &os, const Jump &jump)
Real distance (Jump const &a_in, Jump const &b_in)
 RT root squared deviation.
void jump_distance (Jump const &a_in, Jump const &b_in, Real &dist, Real &theta)
 compare the difference of two jumps in term of the translation (dist) and rotational angle(theta)
std::ostream & operator<< (std::ostream &os, const RT &rt)
std::istream & operator>> (std::istream &is, RT &rt)
Real distance (RT const &a, RT const &b)
 root squared devitation of two RTs
static basic::Tracer tr ("core.kinematics.ShortestPathInFoldTree", basic::t_info)
std::ostream & operator<< (std::ostream &os, Stub const &a)
 output operator, 3x3 matrix followd by an xyzVector
Stub default_stub (Stub::Matrix::identity(), Stub::Vector(0.0))
 Globals.
double distance (Stub const &a, Stub const &b)
 root sqared deviation between two stubs
static
numeric::random::RandomGenerator 
RG (62457)
static basic::Tracer TR ("core.kinematics.util")
tree::Atomadd_atom (int const atomno, int const seqpos, Links const &links, AtomPointer1D &atom_ptr, bool const add_jump_atom)
int pick_loopy_cutpoint (Size const n_res, ObjexxFCL::FArray1D_float const &cut_bias_sum)
 pick a postion in n_res as the cutpoint
tree::Atomsetup_cloned_atom (tree::Atom const *, utility::vector1< id::AtomID > const &)
tree::Atomsetup_backrub_atom_tree (utility::vector1< AtomID >, AtomID const &, AtomPointer2D const &, utility::vector1< std::pair< Size, Size > > const &, Size const )
void simple_visualize_fold_tree (FoldTree const &fold_tree, std::ostream &out)
 prints something like this ***1***C***1*********2***C********3****C****2********3*****
void simple_visualize_fold_tree_and_movemap (FoldTree const &fold_tree, MoveMap const &mm, std::ostream &out)
 prints something like this ***1***C***1*********2***C********3****C****2********3***** xxxxxxxxxxxxx************************************
void simple_visualize_fold_tree_and_movemap_bb_chi (FoldTree const &fold_tree, MoveMap const &mm, std::ostream &out)
 prints something like this ***1***C***1*********2***C********3****C****2********3***** xxxxxxxxxxxxx************************************
core::kinematics::FoldTree linearize_fold_tree (core::kinematics::FoldTree const &tree)
 linearizes (or defoliates, if you prefer) a FoldTree. "default" FoldTrees produced by the PDB reader have all chains (peptide edges) starting from jumps relative to residue 1. This code modifies the tree to instead have all the jumps be relative to the preceding edge. It is not tested with ligands and will not work with "functional" jumps. From A to B: A:FOLD_TREE EDGE 1 78 -1 EDGE 1 79 1 EDGE 79 454 -1 EDGE 1 455 2 EDGE 455 540 -1 EDGE 1 541 3 EDGE 541 697 -1 B:FOLD_TREE EDGE 1 78 -1 EDGE 78 79 1 EDGE 79 454 -1 EDGE 454 455 2 EDGE 455 540 -1 EDGE 540 541 3 EDGE 541 697 -1
tree::Atomadd_atom (int const atomno, int const seqpos, utility::vector1< utility::vector1< Size > > const &links, AtomPointer1D &atom_ptr, bool const add_jump_atom)
 creat an atom and add it to the residue atom-tree based on information stored in links.

Variables

int const dir_jump
static const utility::vector1
< Real
ZERO (6, 0.0)
Stub default_stub
 Globals.

Detailed Description

See AtomTree overview and FoldTree overview for details.


Typedef Documentation

typedef ObjexxFCL::FArray1D_int core::kinematics::DomainMap

Function Documentation

tree::Atom* core::kinematics::add_atom ( int const  atomno,
int const  seqpos,
Links const &  links,
AtomPointer1D &  atom_ptr,
bool const  add_jump_atom 
)

recursively called until all atoms in this reside are added.

Note:
The Atoms that are allocated within this function are owned by the atom_ptr which is a container of AtomOP's (see AtomPointer.fwd.hh)
Returns a raw pointer for internal tree links but memory management is handled by atom_ptr

Referenced by core::coarse::Translator::add_all_remaining(), core::coarse::Translator::add_atom(), core::coarse::Translator::add_remaining_sidechain(), core::scoring::sc::ShapeComplementarityCalculator::AddResidue(), core::conformation::build_residue_tree(), and core::coarse::Translator::Translator().

tree::Atom* core::kinematics::add_atom ( int const  atomno,
int const  seqpos,
utility::vector1< utility::vector1< Size > > const &  links,
AtomPointer1D &  atom_ptr,
bool const  add_jump_atom 
)

creat an atom and add it to the residue atom-tree based on information stored in links.

Stub core::kinematics::default_stub ( Stub::Matrix::  identity(),
Stub::  Vector0.0 
)

Globals.

a stub center at 0.0 with lab frame(identy matrix)

Real core::kinematics::distance ( Jump const &  a_in,
Jump const &  b_in 
)

RT root squared deviation.

References protocols::match::upstream::b, and core::kinematics::Jump::fold_in_rb_deltas().

Referenced by protocols::seeded_abinitio::add_dist_constraints(), protocols::toolbox::task_operations::DesignAroundOperation::apply(), protocols::simple_filters::ResidueDistanceFilter::apply(), protocols::simple_filters::PredictedBurialEvaluator::apply(), protocols::protein_interface_design::movers::PlaceStubMover::apply(), protocols::protein_interface_design::movers::PlacementAuctionMover::apply(), protocols::protein_interface_design::movers::DesignMinimizeHbonds::apply(), protocols::protein_interface_design::movers::AddChainBreak::apply(), protocols::protein_interface_design::ResidueDistanceFilter::apply(), protocols::contact_map::ContactMap::apply(), protocols::abinitio::DomainAssembly::apply(), core::chemical::ResidueType::assign_neighbor_atom(), core::scoring::methods::atoms_interact(), protocols::hotspot_hashing::HotspotStubSet::autofill(), core::pack::rotamer_set::build_optimal_water_O_on_donor(), core::scoring::methods::build_optimal_water_Os_on_acceptor(), core::pack::rotamer_set::build_optimal_water_Os_on_acceptor(), core::chemical::ResidueType::calculate_icoor(), core::chemical::orbitals::AssignOrbitals::calculate_orbital_icoor(), protocols::loops::loop_closure::ccd::check_overlap_pos(), protocols::nonlocal::chunks_by_CA_CA_distance(), protocols::simple_filters::ResidueDistanceFilter::compute(), protocols::simple_filters::ResidueBurialFilter::compute(), protocols::simple_filters::NeighborTypeFilter::compute(), protocols::protein_interface_design::filters::AverageDegreeFilter::compute(), protocols::protein_interface_design::ResidueDistanceFilter::compute(), protocols::protein_interface_design::ResidueBurialFilter::compute(), protocols::protein_interface_design::NeighborTypeFilter::compute(), protocols::enzdes::LigBurialFilter::compute(), core::pack::interaction_graph::SurfacePotential::compute_pose_surface_energy(), core::pack::interaction_graph::SurfacePotential::compute_residue_surface_energy(), protocols::protein_interface_design::movers::SetAtomTree::create_atom_tree(), protocols::forge::build::BuildManager::create_directed_dependency(), protocols::toolbox::match_enzdes_util::GeomSampleInfo::create_sample_vector(), protocols::medal::cutpoint_probabilities(), protocols::relax::derive_sc_sc_restraints(), core::pack::interaction_graph::SurfaceNode< V, E, G >::detect_neighborship_with_node(), protocols::frag_picker::scores::PCS_FragDistance::do_caching(), protocols::frag_picker::scores::DisulfideDistance::do_caching(), core::scoring::dna::DNA_BasePotential::eval_base_pair_derivative(), core::scoring::dna::DNA_BasePotential::eval_base_step_derivative(), protocols::hotspot_hashing::HotspotStubSet::fill(), core::scoring::methods::DistanceChainbreakEnergy::finalize_total_energy(), protocols::seeded_abinitio::find_nearest_residue(), protocols::protein_interface_design::find_nearest_residue(), protocols::protein_interface_design::movers::find_nearest_residue_to_coord(), core::pack::interaction_graph::RotamerDots::get_atom_atom_coverage(), protocols::seeded_abinitio::get_closest_residue_pair(), protocols::swa::rna::get_max_centroid_to_atom_distance(), protocols::hotspot_hashing::HotspotStub::get_nearest_residue(), protocols::hotspot_hashing::HotspotStubSet::get_nearest_stub(), protocols::loops::loop_closure::ccd::get_overlap_pos(), hbonded(), MinimizeInterface(), protocols::protein_interface_design::movers::PlaceSimultaneouslyMover::pair_sets_with_positions(), core::scoring::disulfides::FullatomDisulfidePotential::print_score_functions(), protocols::toolbox::pose_metric_calculators::SaltBridgeCalculator::recompute(), protocols::toolbox::pose_metric_calculators::PiPiCalculator::recompute(), protocols::toolbox::pose_metric_calculators::CatPiCalculator::recompute(), protocols::simple_filters::ResidueDistanceFilter::report(), protocols::protein_interface_design::ResidueDistanceFilter::report(), protocols::simple_filters::ResidueDistanceFilter::report_sm(), protocols::protein_interface_design::ResidueDistanceFilter::report_sm(), core::scoring::interface::DDPscore::residue_pair_energy(), core::scoring::methods::PoissonBoltzmannEnergy::revamp_weight_by_burial(), core::pack::RTMin::rtmin(), core::scoring::disulfides::DisulfideMatchingPotential::score_disulfide(), protocols::toolbox::match_enzdes_util::ExternalGeomSampler::set_dis_D1D2(), protocols::toolbox::match_enzdes_util::ExternalGeomSampler::set_dis_D2D3(), protocols::qsar::scoring_grid::GridBase::set_distance_sphere_for_atom(), protocols::star::setup_constraints(), protocols::medal::setup_coordinate_constraints(), protocols::simple_moves::DesignRepackMover::setup_packer_and_movemap(), core::pack::interaction_graph::SurfaceNode< V, E, G >::verify_patch_areas_correct(), and core::pack::interaction_graph::InvRotamerDots::write_circle_intersection_mask_to_kinemage().

Real core::kinematics::distance ( RT const &  a,
RT const &  b 
) [inline]

root squared devitation of two RTs

double core::kinematics::distance ( Stub const &  a,
Stub const &  b 
) [inline]

root sqared deviation between two stubs

References core::kinematics::Stub::M, and core::kinematics::Stub::v.

void core::kinematics::find_stub_transform ( Stub const &  stub1,
Stub const &  stub2,
RT const &  rt,
Stub::Matrix A,
Vector &  b 
)

void AtomTree::setup_backrub_segment( utility::vector1< AtomID > const & mainchain, AtomID const & downstream_id, // mainchain child of last atom in mainchain vector utility::vector1< std::pair< Size, Size > > const & edges, Size const first_new_pseudo_residue ) {

this assumes that the segment of mainchain has exactly one connection in and exactly one connection out, (to the downstream_id atom) and all of the atoms to be replaced are bonded atoms

for ( Size i=1; i<= mainchain.size(); ++i ) { assert( !( atom_pointer_[ mainchain[i] ]->is_jump() ) ); } AtomID const last_mainchain_id( mainchain[ mainchain.size() ] ); assert( atom_pointer_[ downstream_id ]->parent()->id() == last_mainchain_id );

operation is done "by xyz" leaving the internal coords out of date update_xyz_coords();

Atom * subtree_root ( setup_backrub_atom_tree( mainchain, downstream_id, atom_pointer_, edges, first_new_pseudo_residue ) ); assert( subtree_root->id() == mainchain[1] );

Atom * old_root( atom_pointer_[ mainchain[1] ] ); Atom * anchor( old_root->parent() );

Atom * downstream_atom( atom_pointer_[ downstream_id ] ); downstream_atom->parent()->delete_atom( downstream_atom ); // delete the old outgoing connection

update atom_pointer_ subtree_root->update_atom_pointer( atom_pointer_, true );

insert the new tree anchor->replace_atom( old_root, subtree_root ); // incoming connection atom_pointer_[ last_mainchain_id ]->insert_atom( downstream_atom ); // outoing connection

erase the old tree this call will erase and delete all of old_root's children old_root->erase(); free the last bit of old data delete old_root;

internal_coords_need_updating_ = true;

}

This is a helper function to find a linear transform that when applied to the downstream stub has the effect that RT( instub, transformed-downstream-stub) == target_rt

References core::kinematics::RT::get_rotation(), core::kinematics::RT::get_translation(), core::kinematics::Stub::M, core::scoring::hbonds::t(), and core::kinematics::Stub::v.

Referenced by core::kinematics::AtomTree::set_stub_transform().

void core::kinematics::jump_distance ( Jump const &  a_in,
Jump const &  b_in,
Real dist,
Real theta 
)
static numeric::random::RandomGenerator core::kinematics::jump_RG ( 62454  ) [static]
core::kinematics::FoldTree core::kinematics::linearize_fold_tree ( core::kinematics::FoldTree const &  tree)

linearizes (or defoliates, if you prefer) a FoldTree. "default" FoldTrees produced by the PDB reader have all chains (peptide edges) starting from jumps relative to residue 1. This code modifies the tree to instead have all the jumps be relative to the preceding edge. It is not tested with ligands and will not work with "functional" jumps. From A to B: A:FOLD_TREE EDGE 1 78 -1 EDGE 1 79 1 EDGE 79 454 -1 EDGE 1 455 2 EDGE 455 540 -1 EDGE 1 541 3 EDGE 541 697 -1 B:FOLD_TREE EDGE 1 78 -1 EDGE 78 79 1 EDGE 79 454 -1 EDGE 454 455 2 EDGE 455 540 -1 EDGE 540 541 3 EDGE 541 697 -1

References core::kinematics::FoldTree::add_edge(), core::kinematics::FoldTree::begin(), core::sequence::end, and core::kinematics::FoldTree::end().

bool core::kinematics::operator!= ( Edge const &  a,
Edge const &  b 
)

when any of start residue number, stop residue number and label index number is not equal

References core::kinematics::Edge::label(), core::kinematics::Edge::start(), and core::kinematics::Edge::stop().

bool core::kinematics::operator!= ( const FoldTree &  a,
const FoldTree &  b 
)
bool core::kinematics::operator< ( Edge const &  a,
Edge const &  b 
)

compare start residue number first, then stop residue number, then label index number, then start_atom, then stop_atom

References core::kinematics::Edge::label(), core::kinematics::Edge::start(), core::kinematics::Edge::start_atom(), core::kinematics::Edge::stop(), and core::kinematics::Edge::stop_atom().

std::ostream& core::kinematics::operator<< ( std::ostream &  os,
const Edge &  e 
)
std::ostream& core::kinematics::operator<< ( std::ostream &  os,
const RT &  rt 
)
std::ostream & core::kinematics::operator<< ( std::ostream &  os,
Stub const &  a 
)

output operator, 3x3 matrix followd by an xyzVector

References core::kinematics::Stub::M, and core::kinematics::Stub::v.

std::ostream& core::kinematics::operator<< ( std::ostream &  os,
FoldTree const &  t 
)

Foldtree output to stream

References core::kinematics::FoldTree::begin(), and core::kinematics::FoldTree::end().

std::ostream& core::kinematics::operator<< ( std::ostream &  os,
const Jump &  jump 
)
bool core::kinematics::operator== ( Edge const &  a,
Edge const &  b 
)

when start residue number, stop residue number and label index number are all equal

References core::kinematics::Edge::label(), core::kinematics::Edge::start(), core::kinematics::Edge::start_atom(), core::kinematics::Edge::stop(), and core::kinematics::Edge::stop_atom().

bool core::kinematics::operator== ( FoldTree const &  a,
FoldTree const &  b 
)

Checks that edges are in the same order and are equal

References core::graph::EdgeList::begin(), core::graph::EdgeList::end(), and core::graph::EdgeList::size().

std::istream& core::kinematics::operator>> ( std::istream &  is,
RT &  rt 
)
std::istream& core::kinematics::operator>> ( std::istream &  is,
Edge &  e 
)
std::istream& core::kinematics::operator>> ( std::istream &  is,
FoldTree &  t 
)
std::istream& core::kinematics::operator>> ( std::istream &  is,
Jump &  jump 
)

References ZERO.

int core::kinematics::pick_loopy_cutpoint ( Size const  n_res,
ObjexxFCL::FArray1D_float const &  cut_bias_sum 
)

pick a postion in n_res as the cutpoint

this is done based on probability info stored in cut_bias_sum. This function is used during fold_tree construction.

References RG(), and TR().

static numeric::random::RandomGenerator core::kinematics::RG ( 62457  ) [static]
tree::Atom * core::kinematics::setup_backrub_atom_tree ( utility::vector1< AtomID >  ,
AtomID const &  ,
AtomPointer2D const &  ,
utility::vector1< std::pair< Size, Size > > const &  ,
Size  const 
)

in principal, this should be the inverse of the build_tree function at the beginning

tree::Atom* core::kinematics::setup_cloned_atom ( tree::Atom const *  ,
utility::vector1< id::AtomID > const &   
)

helper function for setup_backrub_atom_tree

void core::kinematics::simple_visualize_fold_tree ( FoldTree const &  fold_tree,
std::ostream &  out 
)
void core::kinematics::simple_visualize_fold_tree_and_movemap ( FoldTree const &  fold_tree,
MoveMap const &  mm,
std::ostream &  out 
)
void core::kinematics::simple_visualize_fold_tree_and_movemap_bb_chi ( FoldTree const &  fold_tree,
MoveMap const &  mm,
std::ostream &  out 
)
static basic::Tracer core::kinematics::TR ( "core.kinematics.AtomTree"  ) [static]
static basic::Tracer core::kinematics::tr ( "core.kinematics.ShortestPathInFoldTree"  ,
basic::t_info   
) [static]
static basic::Tracer core::kinematics::tr ( "core.kinematics"  ) [static]
static basic::Tracer core::kinematics::TR ( "core.kinematics.util"  ) [static]

Variable Documentation

const utility::vector1<Real> core::kinematics::ZERO(6, 0.0) [static]
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines