core::kinematics Namespace Reference

Namespaces
	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...
struct	Node
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...
struct	TreeVizBuilder

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< Size >	ResidueIndexList
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
void	find_stub_transform (Stub const &stub1, Stub const &stub2, RT const &rt, Stub::Matrix &A, Vector &b)
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)
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. More...
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) More...
std::ostream &	operator<< (std::ostream &out, MoveMap const &mm)
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 More...
std::ostream &	operator<< (std::ostream &os, Stub const &a)
	output operator, 3x3 matrix followed by an xyzVector More...
Stub	default_stub (Stub::Matrix::identity(), Stub::Vector(0.0))
double	distance (Stub const &a, Stub const &b)
	root squared deviation between two stubs More...
tree::AtomOP	add_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 More...
tree::AtomOP	setup_cloned_atom (tree::AtomCOP, utility::vector1< id::AtomID > const &)
	helper function for setup_backrub_atom_tree More...
tree::AtomOP	setup_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***** More...
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************************************ More...
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************************************ More...
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 More...
void	replace_substr (std::string &str, const std::string from, const std::string to)
std::string	operator* (std::string const s, size_t n)
std::string	pad_dash (Size npad, std::string s)
std::string	pad_dash_left (Size npad, std::string s)
std::string	pad_dash_right (Size npad, std::string s)
std::string	visualize_fold_tree (FoldTree const &ft, std::map< Size, std::string > const &node_labels_partial_in, std::map< Size, char > const &mark_jump_to_res, std::map< Size, Size > const &jump_follows)
std::string	visualize_fold_tree (FoldTree const &fold_tree)
	sheffler More...
std::string	visualize_fold_tree (FoldTree const &ft, std::map< Size, std::string > const &node_labels_partial)
std::string	visualize_fold_tree (FoldTree const &ft, std::map< Size, char > const &mark_jump_to_res)
core::kinematics::FoldTree	remodel_fold_tree_to_account_for_insertion (core::kinematics::FoldTree const &input_tree, core::Size insert_after, core::Size insert_size)
	remodel a fold tree to account for a large insertion by adding the size of the insert to upstream positions More...
tree::AtomOP	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. More...

Variables
static basic::Tracer	TR ("core.kinematics.AtomTree")
int const	dir_jump (0)
static basic::Tracer	tr ("core.kinematics")
static numeric::random::RandomGenerator	jump_RG (62454)
static const utility::vector1 < Real >	ZERO (6, 0.0)
static basic::Tracer	tr ("core.kinematics.ShortestPathInFoldTree", basic::t_info)
Stub	default_stub
	Global default stub. More...
static numeric::random::RandomGenerator	RG (62457)
static basic::Tracer	TR ("core.kinematics.util")

Typedef Documentation

typedef utility::vector1< AtomWithDOFChange > core::kinematics::AtomDOFChangeSet

typedef utility::vector1< tree::AtomOP > core::kinematics::AtomPointer1D

typedef id::AtomID_Map< tree::AtomOP > core::kinematics::AtomPointer2D

typedef utility::pointer::access_ptr< AtomTree > core::kinematics::AtomTreeAP

typedef utility::pointer::access_ptr< AtomTree const > core::kinematics::AtomTreeCAP

typedef utility::pointer::owning_ptr< AtomTree const > core::kinematics::AtomTreeCOP

typedef utility::pointer::owning_ptr< AtomTree > core::kinematics::AtomTreeOP

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

typedef utility::pointer::access_ptr< Edge > core::kinematics::EdgeAP

typedef utility::pointer::owning_ptr< Edge > core::kinematics::EdgeOP

typedef utility::pointer::access_ptr< FoldTree > core::kinematics::FoldTreeAP

typedef utility::pointer::access_ptr< FoldTree const > core::kinematics::FoldTreeCAP

typedef utility::pointer::owning_ptr< FoldTree const > core::kinematics::FoldTreeCOP

typedef utility::pointer::owning_ptr< FoldTree > core::kinematics::FoldTreeOP

typedef utility::vector1< utility::vector1< Size > > core::kinematics::Links

typedef utility::pointer::owning_ptr< MinimizerMapBase const > core::kinematics::MinimizerMapBaseCOP

typedef utility::pointer::owning_ptr< MinimizerMapBase > core::kinematics::MinimizerMapBaseOP

typedef utility::pointer::owning_ptr< MoveMap const > core::kinematics::MoveMapCOP

typedef utility::pointer::owning_ptr< MoveMap > core::kinematics::MoveMapOP

typedef utility::pointer::owning_ptr< ResidueCoordinateChangeList > core::kinematics::ResidueCoordinateChangeListOP

typedef utility::vector1< Size > core::kinematics::ResidueIndexList

typedef utility::vector1< Size >::const_iterator core::kinematics::ResidueListIterator

typedef utility::pointer::access_ptr< RT > core::kinematics::RTAP

typedef utility::pointer::owning_ptr< RT > core::kinematics::RTOP

typedef utility::pointer::access_ptr< ShortestPathInFoldTree > core::kinematics::ShortestPathInFoldTreeAP

typedef utility::pointer::owning_ptr< ShortestPathInFoldTree const > core::kinematics::ShortestPathInFoldTreeCOP

typedef utility::pointer::owning_ptr< ShortestPathInFoldTree > core::kinematics::ShortestPathInFoldTreeOP

Function Documentation

tree::AtomOP 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.

tree::AtomOP 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::conformation::build_residue_tree(), and core::coarse::Translator::Translator().

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

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

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

inline

root squared deviation between two stubs

References numeric::xyzMatrix< class >::col_x(), numeric::xyzMatrix< class >::col_y(), numeric::xyzMatrix< class >::col_z(), numeric::xyzVector< class >::distance_squared(), core::kinematics::Stub::M, and core::kinematics::Stub::v.

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

inline

root squared devitation of two RTs

References numeric::xyzMatrix< class >::col(), numeric::xyzVector< class >::distance_squared(), core::kinematics::RT::rotation, and core::kinematics::RT::translation.

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

RT root squared deviation.

References core::kinematics::Jump::fold_in_rb_deltas(), and core::kinematics::Jump::rt_.

Referenced by core::chemical::ResidueType::assign_neighbor_atom(), core::chemical::orbitals::AssignOrbitals::assign_orbitals(), core::scoring::methods::atoms_interact(), 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::orbitals::AssignOrbitals::calculate_orbital_icoor(), core::pack::interaction_graph::SurfacePotential::compute_pose_surface_energy(), core::pack::interaction_graph::SurfacePotential::compute_residue_surface_energy(), core::pack::interaction_graph::SurfaceNode< V, E, G >::detect_neighborship_with_node(), core::fragment::picking_old::concepts::Extent< PageIterator >::distance(), core::fragment::picking_old::vall::scores::VallFragmentScore::distance(), core::scoring::methods::LinearChainbreakEnergy::do_score_ovp(), core::scoring::dna::DNA_BasePotential::eval_base_pair_derivative(), core::scoring::dna::DNA_BasePotential::eval_base_step_derivative(), core::scoring::methods::CartesianBondedEnergy::eval_interresidue_bond_energy(), core::scoring::methods::DistanceChainbreakEnergy::finalize_total_energy(), core::pack::interaction_graph::RotamerDots::get_atom_atom_coverage(), core::scoring::nv::NVscore::neighbor_weight(), core::pack::interaction_graph::InvRotamerDots::overlap_exposed(), core::scoring::disulfides::FullatomDisulfidePotential::print_score_functions(), core::chemical::ResidueDatabaseIO::read_residue_type_icoor(), 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(), core::pack::task::residue_selector::NeighborhoodResidueSelector::set_distance(), core::pack::interaction_graph::SurfaceNode< V, E, G >::verify_patch_areas_correct(), core::pack::interaction_graph::InvRotamerDots::write_circle_intersection_mask_to_kinemage(), and core::chemical::ResidueDatabaseIO::write_residue_type_icoor_table_schema().

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

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
	)

compare the difference of two jumps in term of the translation (dist) and rotational angle(theta)

References core::chemical::element::B, core::kinematics::Jump::fold_in_rb_deltas(), core::kinematics::Jump::get_rotation(), core::kinematics::Jump::get_translation(), rotation_axis(), and w().

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!=	(	const FoldTree &	a,
		const FoldTree &	b
	)

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

std::string core::kinematics::operator*	(	std::string const	s,
		size_t	n
	)

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,
		Stub const &	a
	)

output operator, 3x3 matrix followed by an xyzVector

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

std::ostream& core::kinematics::operator<<	(	std::ostream &	os,
		const Edge &	e
	)

References core::kinematics::Edge::CHEMICAL, core::kinematics::Edge::has_atom_info(), core::kinematics::Edge::is_jump(), core::kinematics::Edge::keep_stub_in_residue(), core::kinematics::Edge::label(), core::kinematics::Edge::start(), core::kinematics::Edge::start_atom(), core::kinematics::Edge::stop(), core::kinematics::Edge::stop_atom(), and tag.

std::ostream& core::kinematics::operator<<	(	std::ostream &	os,
		const RT &	rt
	)

References core::kinematics::RT::ortho_check(), core::kinematics::RT::rotation, and core::kinematics::RT::translation.

std::ostream& core::kinematics::operator<<	(	std::ostream &	os,
		const Jump &	jump
	)

References core::kinematics::Jump::nonzero_deltas(), core::kinematics::Jump::rb_center, core::kinematics::Jump::rb_delta, core::kinematics::Jump::rt_, and tag.

std::ostream& core::kinematics::operator<< ( std::ostream &  out, MoveMap const &  mm  )

inline

References core::kinematics::MoveMap::show().

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

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

Checks that edges are in the same order and are equal

References core::kinematics::FoldTree::edge_list_.

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

std::istream& core::kinematics::operator>>	(	std::istream &	is,
		Edge &	e
	)

References core::kinematics::Edge::bKeepStubInResidue_, core::kinematics::Edge::CHEMICAL, core::kinematics::Edge::is_jump(), core::kinematics::Edge::label(), core::kinematics::Edge::label_, core::kinematics::Edge::start_, core::kinematics::Edge::start_atom_, core::kinematics::Edge::stop_, core::kinematics::Edge::stop_atom_, tag, and tr.

std::istream& core::kinematics::operator>>	(	std::istream &	is,
		RT &	rt
	)

References core::kinematics::RT::ortho_check(), core::kinematics::RT::rotation, tag, and core::kinematics::RT::translation.

std::istream& core::kinematics::operator>>	(	std::istream &	is,
		Jump &	jump
	)

References core::kinematics::Jump::rb_center, core::kinematics::Jump::rb_delta, core::kinematics::Jump::rt_, and ZERO.

std::istream& core::kinematics::operator>>	(	std::istream &	is,
		FoldTree &	t
	)

Foldtree input from stream

References core::kinematics::FoldTree::check_fold_tree(), core::kinematics::FoldTree::edge_list_, core::kinematics::FoldTree::new_topology, core::kinematics::FoldTree::reorder(), core::scoring::hbonds::t, tag, and TR.

std::string core::kinematics::pad_dash	(	Size	npad,
		std::string	s
	)

Referenced by core::kinematics::Node::str().

std::string core::kinematics::pad_dash_left	(	Size	npad,
		std::string	s
	)

Referenced by core::kinematics::Node::str().

std::string core::kinematics::pad_dash_right	(	Size	npad,
		std::string	s
	)

Referenced by core::kinematics::Node::str().

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, TR, and numeric::random::RandomGenerator::uniform().

Referenced by core::kinematics::FoldTree::cut_random_edge().

core::kinematics::FoldTree core::kinematics::remodel_fold_tree_to_account_for_insertion	(	core::kinematics::FoldTree const &	input_tree,
		core::Size	insert_after,
		core::Size	insert_size
	)

remodel a fold tree to account for a large insertion by adding the size of the insert to upstream positions

Author

Steven Lewis smlew.nosp@m.i@gm.nosp@m.ail.c.nosp@m.om as a favor for Jared

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

void core::kinematics::replace_substr	(	std::string &	str,
		const std::string	from,
		const std::string	to
	)

Referenced by core::kinematics::Node::str().

tree::AtomOP 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

References utility_exit_with_message.

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

helper function for setup_backrub_atom_tree

References utility_exit_with_message.

void core::kinematics::simple_visualize_fold_tree	(	FoldTree const &	fold_tree,
		std::ostream &	out
	)

prints something like this ***1***C***1*********2***C********3****C****2********3*****

References core::kinematics::FoldTree::is_cutpoint(), core::kinematics::FoldTree::is_jump_point(), core::kinematics::FoldTree::jump_edge(), core::kinematics::FoldTree::nres(), core::kinematics::FoldTree::num_jump(), core::kinematics::Edge::start(), and core::kinematics::Edge::stop().

void core::kinematics::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************************************

References core::kinematics::MoveMap::get_bb(), core::kinematics::FoldTree::is_cutpoint(), core::kinematics::FoldTree::is_jump_point(), core::kinematics::FoldTree::jump_edge(), move, core::kinematics::FoldTree::nres(), core::kinematics::FoldTree::num_jump(), core::kinematics::Edge::start(), and core::kinematics::Edge::stop().

void core::kinematics::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************************************

References core::kinematics::MoveMap::get_bb(), core::kinematics::MoveMap::get_chi(), core::kinematics::FoldTree::is_cutpoint(), core::kinematics::FoldTree::is_jump_point(), core::kinematics::FoldTree::jump_edge(), move, core::kinematics::FoldTree::nres(), core::kinematics::FoldTree::num_jump(), core::kinematics::Edge::start(), and core::kinematics::Edge::stop().

std::string core::kinematics::visualize_fold_tree	(	FoldTree const &	ft,
		std::map< Size, std::string > const &	node_labels_partial_in,
		std::map< Size, char > const &	mark_jump_to_res,
		std::map< Size, Size > const &	jump_follows
	)

References core::kinematics::FoldTree::downstream_jump_residue(), core::kinematics::TreeVizBuilder::expand_node_labels_partial_by_contig(), core::kinematics::TreeVizBuilder::get_ft_node_bounds(), core::kinematics::TreeVizBuilder::get_jump_num_to_contig_of_resi(), core::kinematics::TreeVizBuilder::get_res_nodenames(), core::kinematics::TreeVizBuilder::is_single(), core::kinematics::FoldTree::nres(), core::kinematics::FoldTree::num_jump(), core::kinematics::FoldTree::upstream_jump_residue(), and utility_exit_with_message.

Referenced by core::conformation::symmetry::setup_symmetric_conformation(), core::conformation::symmetry::show_foldtree(), and visualize_fold_tree().

std::string core::kinematics::visualize_fold_tree

(

FoldTree const &

ft

)

sheffler

References visualize_fold_tree().

std::string core::kinematics::visualize_fold_tree	(	FoldTree const &	ft,
		std::map< Size, std::string > const &	node_labels_partial
	)

References visualize_fold_tree().

std::string core::kinematics::visualize_fold_tree	(	FoldTree const &	ft,
		std::map< Size, char > const &	mark_jump_to_res
	)

References visualize_fold_tree().

Variable Documentation

Stub core::kinematics::default_stub

Global default stub.

Referenced by core::kinematics::tree::Atom_::get_input_stub(), and core::kinematics::AtomTree::update_internal_coords().

int const core::kinematics::dir_jump

Referenced by core::conformation::build_residue_tree(), core::conformation::get_anchor_and_root_atoms(), core::conformation::get_anchor_atomno(), core::conformation::get_root_atomno(), core::conformation::get_root_residue_root_atomno(), and core::conformation::Conformation::jump_atom_id().

numeric::random::RandomGenerator core::kinematics::jump_RG(62454)

static

Referenced by core::kinematics::Jump::gaussian_move(), core::kinematics::Jump::gaussian_move_single_rb(), and core::kinematics::Jump::random_trans().

numeric::random::RandomGenerator core::kinematics::RG(62457)

static

Referenced by pick_loopy_cutpoint().

basic::Tracer core::kinematics::tr("core.kinematics")

static

Referenced by core::kinematics::ShortestPathInFoldTree::build_jumpres_distmap(), core::kinematics::ResidueCoordinateChangeList::mark_residue_moved(), and operator>>().

basic::Tracer core::kinematics::TR("core.kinematics.AtomTree")

static

Referenced by core::kinematics::AtomTree::bond_angle(), core::kinematics::AtomTree::bond_length(), core::kinematics::AtomTree::get_frag_local_stub(), core::kinematics::AtomTree::insert_fragment(), pick_loopy_cutpoint(), core::kinematics::AtomTree::promote_sameresidue_nonjump_child(), core::kinematics::AtomTree::set_torsion_angle(), core::kinematics::AtomTree::torsion_angle(), and core::kinematics::AtomTree::torsion_angle_dof_id().

basic::Tracer core::kinematics::TR("core.kinematics.util")

static

basic::Tracer core::kinematics::tr("core.kinematics.ShortestPathInFoldTree", basic::t_info)

static

const utility::vector1<Real> core::kinematics::ZERO(6, 0.0)

static

Referenced by core::kinematics::Jump::fold_in_rb_deltas(), core::kinematics::Jump::from_bond_cst(), core::kinematics::Jump::from_stubs(), core::kinematics::Jump::identity_transform(), operator>>(), and core::kinematics::Jump::reset().