Rosetta 3.4
Public Types | Public Member Functions | Friends
core::kinematics::FoldTree Class Reference

The FoldTree is a residue-based treelike representation of a molecule. More...

#include <FoldTree.hh>

Inheritance diagram for core::kinematics::FoldTree:
Inheritance graph
[legend]
Collaboration diagram for core::kinematics::FoldTree:
Collaboration graph
[legend]

List of all members.

Public Types

typedef std::vector< EdgeEdgeList
typedef EdgeList::iterator iterator
typedef EdgeList::const_iterator const_iterator

Public Member Functions

 FoldTree ()
 constructor
 FoldTree (int const nres_in)
 Constructs a simple FoldTree.
FoldTreeoperator= (FoldTree const &src)
 operator=
Size boundary_left (Size res) const
 Returns the starting residue of the kinematic chunk to which res belongs.
Size boundary_right (Size res) const
 Returns the ending residue of the kinematic chunk to which res belongs.
int size () const
 Returns the number of edges in the FoldTree.
const_iterator begin () const
 begin iterator of the edge_list
const_iterator end () const
 end iterator of the edge_list
void show (std::ostream &out) const
 Displays the FoldTree information.
void add_edge (int const start, int const stop, int const label)
 Adds an edge from <start> to <stop>
void add_edge (int const start, int const stop, std::string const &start_atom, std::string const &stop_atom)
 Especially useful version of add_edge for chemical edge construction.
void add_edge (Edge const &new_edge)
 Add the edge <new_edge>
void delete_edge (iterator edge)
 Deletes the edge <edge> in the FoldTree by iterator.
void delete_edge (Edge const &edge)
 Delete the edge <edge> in the fold tree by example edge.
void delete_unordered_edge (int const start, int const stop, int const label)
 Find an edge in fold tree and delete it.
void update_edge_label (int const start, int const stop, int const old_label, int const new_label)
 Changes the label of an edge in fold tree.
int edge_label (int const start, int const stop)
 Returns the edge label of the edge from <start> to <stop>
void clear ()
 Deletes all edge in the FoldTree.
void renumber_jumps ()
 Renumbers the jump edges in the FoldTree How?
void delete_self_edges ()
 Deletes edges with start==stop allowable 1->1 edge for single residue FoldTree.
void delete_extra_vertices ()
 Delete vertices that are no longer necessary any more How is this determined?
void delete_segment (int const seg_begin, int const seg_end)
 Deletes a continuous segment from <seq_begin> to <seq_end>
void delete_seqpos (int const seqpos)
 Deletes the residue <seqpos> from the FoldTree. Will rearrange topology if necessary.
void insert_polymer_residue (int const seqpos, bool const join_lower, bool const join_upper)
 Inserts a polymer residue at position <seqpos> How?
void insert_residue_by_jump (int const seqpos, int anchor_pos, std::string const &anchor_atom="", std::string const &root_atomno="")
 Inserts a residue attached only by a jump. precondition is that seqpos-1 is a cutpoint.
void insert_fold_tree_by_jump (FoldTree const &subtree, int const insert_seqpos, int const insert_jumppos, int const anchor_pos, int anchor_jump_number=0, std::string const &anchor_atom="", std::string const &root_atom="")
 Inserts a fold_tree as a subtree.
void apply_sequence_mapping (id::SequenceMapping const &old2new)
 Renumber all vertices according to an input sequence mapping.
int new_jump (int const jump_pos1, int const jump_pos2, int const cutpoint)
 Adds a new jump edge from <pos1> to <pos2> with cutpoint <cutpoint>
void new_chemical_bond (int const anchor_pos, int const root_pos, std::string const &anchor_atom, std::string const &root_atom, int const new_cutpoint)
void simple_tree (int const nres_in)
 Produces a 1-edge FoldTree that is <nres_in> long No jumps or extraneous features.
bool is_simple_tree () const
 Returns true if the FoldTree has 1-edge (non-jump)
bool random_tree_from_jump_points (int const nres_in, int const num_jump_in, ObjexxFCL::FArray2D_int const &jump_point, ObjexxFCL::FArray1D_float const &cut_bias, int const root_in=1, bool const allow_jump_at_1_or_NRES=false)
 Builds a FoldTree from a list of <jump_points> and random cut points based on some biased probability Returns bool about success.
bool random_tree_from_jump_points (int const nres_in, int const num_jump_in, ObjexxFCL::FArray2D_int const &jump_point, std::vector< int > const &obligate_cut_points, ObjexxFCL::FArray1D_float const &cut_bias, int const root_in=1, bool const allow_jump_at_1_or_NRES=false)
 Builds a FoldTree from a list of <jump_points> and random cut points based on some biased probability and any user-defined obligate cutpoints Returns bool about success.
bool tree_from_jumps_and_cuts (int const nres_in, int const num_jump_in, ObjexxFCL::FArray2D_int const &jump_point, ObjexxFCL::FArray1D_int const &cuts, int const root_in=1, bool const verbose=false)
 Constructs a FoldTree from listed <jump point>=""> and <cuts> Returns bool about success.
void append_residue (bool const attach_by_jump=false, int const jump_anchor_residue=0, std::string const &jump_upstream_atom="", std::string const &jump_downstream_atom="")
 Appends a new residue to the tree, either by a jump or as a continuation of a peptide segment.
void append_residue_by_chemical_bond (int const anchor_residue, std::string const &anchor_atom, std::string const &root_atom)
 Appends a new residue to the tree using a chemical (APL-style) connection.
bool reorder (int const start_residue)
 Reorders the FoldTree to start at residue <start_residue>
bool check_fold_tree () const
 Returns true if this is a valid FoldTree.
bool connected () const
 Returns true if the FoldTree is connected.
bool check_edges_for_atom_info () const
 chemical edges should have atom info
int upstream_jump_residue (int const jump_number) const
 the staring residue for this jump
int downstream_jump_residue (int const jump_number) const
 the stopping residue for this jump
void partition_by_jump (int const jump_number, FoldTree &f1, FoldTree &f2) const
 partition into two foldtrees by cutting at jump= jump_number
void partition_by_jump (int const jump_number, ObjexxFCL::FArray1D_bool &partner1) const
 partition the fold tree in two parts if the jump is disconnected.
void partition_by_residue (int const seqpos, ObjexxFCL::FArray1D_bool &partner1) const
 partition the fold tree in two parts if a cut would be introduced between seqpos and seqpos+1
int cutpoint_by_jump (int const jump_number) const
 Returns the corresponding cutpoint position for jump <jump_number> WARNING: if you look for all cutpoints by cycling thru jump_numbers you may be dissapointed you will get most likely the same cutpoint for several different jump_numbers however: the method cutpoint( nr ) will give you the number you are looking for.
std::string upstream_atom (int const jump_number) const
 the jump atom on the staring side
std::string downstream_atom (int const jump_number) const
 the jump atom on the stopping side
int get_polymer_residue_direction (int const seqpos) const
 Returns the direction (n2c, c2n) in which the given (peptide) residue is built during folding.
Edge const & get_residue_edge (int const seqpos) const
 Returns the edge that builds the residue <seqpos> Does not work for root atom (will fail)
utility::vector1< Edgeget_outgoing_edges (int const seqpos) const
 Returns all edges that build a residue directly off of <seqpos>
int get_jump_that_builds_residue (int const seqpos) const
 Get the number of the jump that builds (connects to) a given residue.
void set_jump_atoms (int const jump_number, std::string const &upstream_atom, std::string const &downstream_atom, bool bKeepStubInResidue=false)
 define the specific atoms that should be connected by this jump
void set_jump_atoms (int const jump_number, core::Size res1, std::string const &atom1, core::Size res2, std::string const &atom2, bool bKeepStubInResidue=false)
void put_jump_stubs_intra_residue ()
 this reorganizes upstream/downstream atoms of all jumps such that stubs are N-CA-C
void reassign_atoms_for_intra_residue_stubs ()
 this reorganizes upstream/downstream atoms of jumps that have flag keep_stub_in_resiue = true such that stubs are N-CA-C
size_t hash_value () const
Size nres () const
 Returns the number of residues in the FoldTree.
Size num_jump () const
 Returns the number of jumps in the FoldTree.
int jump_point (int const lower_higher, int const jump_number) const
 starting or stopping residue of a jump edge
bool is_jump_point (int const seqpos) const
 Returns true if <seqpos> is a starting or stopping residue of a jump edge.
int cutpoint (int const cut) const
 Returns the cutpoint position of jump number <cut>
int num_cutpoint () const
 Returns the number of cutpoints in the FoldTree.
bool is_cutpoint (int const seqpos) const
 Returns true is position <seqpos> is a cutpoint.
int cutpoint_map (int const seqpos) const
 cutpoint number for this residue
Edge const & jump_edge (int const jump_number) const
 Returns the jump edge with jump number <jump_number> (const)
Edgejump_edge (int const jump_number)
 Returns the jump edge with jump number <jump_number> (non-const)
core::Size jump_nr (core::Size upstream_res, core::Size downstream_res) const
 get the jump_nr connected to jump upstream->downstream, returns 0 if not found
bool empty () const
 Returns true if the FoldTree is empty.
bool is_root (int const seqpos) const
 Returns true if <seqpos> the the root.
int root () const
 Returns the root vertex position of the FoldTree.
bool jump_exists (int const pos1, int const pos2) const
 Return true if a jump exists between <pos1> and <pos2>
Size count_fixed_residues (Size const begin_res, Size const size, Size &min_edge_count_out) const
utility::vector1< intcutpoints () const
 get all cutpoints
void slide_cutpoint (Size const current_cut, Size const target_cut)
 Slide a polymer cutpoint from one location to another.
void slide_jump (Size const jump_number, Size const new_res1, Size const new_res2)
 change an existing jump to start and end in new positions
void delete_jump_and_intervening_cutpoint (int jump_begin, int jump_end)
 Useful for removing a loop modeling jump+cut.
void delete_jump_and_intervening_cutpoint (int const jump_number)
 Useful for removing a loop modeling jump+cut.

Friends

std::istream & operator>> (std::istream &is, FoldTree &t)
 input operator
std::ostream & operator<< (std::ostream &os, FoldTree const &t)
 output operator
bool operator== (FoldTree const &a, FoldTree const &b)
 equal to operator
bool operator!= (const FoldTree &a, const FoldTree &b)
 Not equal to operator.

Detailed Description

The FoldTree is a residue-based treelike representation of a molecule.

Note:
all the derived data is "mutable", so that we can update them as needed on the fly inside "const" member functions this emphasizes that the core data is just the edge_list_
see FoldTree overview and concepts for details

Common Methods: FoldTree.check_fold_tree FoldTree.clear FoldTree.new_jump FoldTree.nres FoldTree.num_jump FoldTree.simple_tree Foldtree.size


Member Typedef Documentation

typedef EdgeList::const_iterator core::kinematics::FoldTree::const_iterator
typedef EdgeList::iterator core::kinematics::FoldTree::iterator

Constructor & Destructor Documentation

core::kinematics::FoldTree::FoldTree ( ) [inline]

constructor

core::kinematics::FoldTree::FoldTree ( int const  nres_in) [inline]

Constructs a simple FoldTree.

ft = FoldTree( nres_in )

int nres_in /the number of residues in this simple tree

References simple_tree().


Member Function Documentation

void core::kinematics::FoldTree::add_edge ( int const  start,
int const  stop,
int const  label 
)
void core::kinematics::FoldTree::add_edge ( int const  start,
int const  stop,
std::string const &  start_atom,
std::string const &  stop_atom 
)

Especially useful version of add_edge for chemical edge construction.

void core::kinematics::FoldTree::add_edge ( Edge const &  new_edge)

Add the edge <new_edge>

example(s): ft.add_edge(edge1) See also: FoldTree FoldTree.check_fold_tree FoldTree.delete_edge FoldTree.jump_edge FoldTree.nres FoldTree.num_jump

Does not ensure proper folding order

void core::kinematics::FoldTree::append_residue ( bool const  attach_by_jump = false,
int const  jump_anchor_residue = 0,
std::string const &  jump_upstream_atom = "",
std::string const &  jump_downstream_atom = "" 
)

Appends a new residue to the tree, either by a jump or as a continuation of a peptide segment.

Add a new residue -- either polymer or jump -- to the end of the tree if the new residue is appended by polymer connection, add it at the end of polymer. if the new residue is appended by jump connection, the cutpoint is the original polymer end

void core::kinematics::FoldTree::append_residue_by_chemical_bond ( int const  anchor_residue,
std::string const &  anchor_atom,
std::string const &  root_atom 
)

Appends a new residue to the tree using a chemical (APL-style) connection.

void core::kinematics::FoldTree::apply_sequence_mapping ( id::SequenceMapping const &  old2new)

Renumber all vertices according to an input sequence mapping.

Renumber all vertices according to an input sequence mapping

References make_table_of_pilot_apps::begin, and core::sequence::end.

const_iterator core::kinematics::FoldTree::begin ( ) const [inline]
Size core::kinematics::FoldTree::boundary_left ( Size  res) const [inline]

Returns the starting residue of the kinematic chunk to which res belongs.

References get_residue_edge(), is_root(), nres(), and core::kinematics::Edge::start().

Size core::kinematics::FoldTree::boundary_right ( Size  res) const [inline]

Returns the ending residue of the kinematic chunk to which res belongs.

References get_residue_edge(), is_root(), nres(), and core::kinematics::Edge::stop().

bool core::kinematics::FoldTree::check_edges_for_atom_info ( ) const

chemical edges should have atom info

References TR().

bool core::kinematics::FoldTree::check_fold_tree ( ) const

Returns true if this is a valid FoldTree.

example(s): ft.check_fold_tree() See also: FoldTree FoldTree.check_fold_tree FoldTree.clear FoldTree.is_simple_tree FoldTree.new_jump FoldTree.nres FoldTree.num_jump FoldTree.simple_tree

Check to see if a foldtree is in valid folding order. To be valid, a fold tree needs to be connected, but not cyclic. So the tree is traversed from the root residue and if any residue has not been visited or has been visited multiple times, the fold tree is bad.

References TR().

Referenced by protocols::frag_picker::nonlocal::NonlocalFrags::apply(), protocols::loops::apply_sequence_mapping(), core::fragment::make_pose_from_frags(), protocols::enzdes::EnzdesFlexibleRegion::minimize_region(), core::kinematics::operator>>(), and protocols::rigid::RigidBodyMotionMover::set_fold_tree().

void core::kinematics::FoldTree::clear ( ) [inline]
bool core::kinematics::FoldTree::connected ( ) const

Returns true if the FoldTree is connected.

Is the tree connected? returns true if fold_tree is connected doesnt assume that the fold_tree is in valid folding order, or even a tree

Size core::kinematics::FoldTree::count_fixed_residues ( Size const  begin_res,
Size const  size,
Size min_edge_count_out 
) const
int core::kinematics::FoldTree::cutpoint ( int const  cut) const [inline]
int core::kinematics::FoldTree::cutpoint_by_jump ( int const  jump_number) const

Returns the corresponding cutpoint position for jump <jump_number> WARNING: if you look for all cutpoints by cycling thru jump_numbers you may be dissapointed you will get most likely the same cutpoint for several different jump_numbers however: the method cutpoint( nr ) will give you the number you are looking for.

To keep the fold tree non-cyclic, for each jump added, there should be a corresponding cutpoint. First call partition_by_jump() and the cutpoint for this jump would be those two sequentially adjacent residues which are not connected any more if the jump is disconnected.

Note:
This cutpoint is not necessarily unique if the foldtree is sufficiently complex. Chooses the first cutpoint with the desired property, starting at the N-terminus. Will be unique eg if the jump is the intra-template jump used to support a single loop region during loop modeling.

References TR().

Referenced by protocols::docking::InterfaceSidechainMinMover::apply(), core::pack::task::operation::DockingNoRepack2::apply(), core::pack::task::operation::DockingNoRepack1::apply(), protocols::docking::DockTaskFactory::create_and_attach_task_factory(), and protocols::scoring::Interface::set_pack().

int core::kinematics::FoldTree::cutpoint_map ( int const  seqpos) const [inline]

cutpoint number for this residue

cutpoint_map is the inverse of cutpoint_, ie it assigns each sequence position that is a cutpoint to the cutpoint number associated with that cutpoint (cutpoints are numbered in increasing residue number from the beginning of the chain)

utility::vector1< int > core::kinematics::FoldTree::cutpoints ( ) const
void core::kinematics::FoldTree::delete_edge ( FoldTree::iterator  edge)

Deletes the edge <edge> in the FoldTree by iterator.

die if the iterator is out of range

References TR().

Referenced by protocols::anchored_design::AnchoredDesignMover::set_fold_tree_and_cutpoints().

void core::kinematics::FoldTree::delete_edge ( Edge const &  edge)

Delete the edge <edge> in the fold tree by example edge.

example(s): ft.delete_edge(edge1) See also: FoldTree FoldTree.add_edge FoldTree.check_fold_tree FoldTree.jump_edge FoldTree.nres FoldTree.num_jump

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

void core::kinematics::FoldTree::delete_extra_vertices ( )

Delete vertices that are no longer necessary any more How is this determined?

after deleting a jump, there may be vertices of the tree which are neither jumps nor cutpoints. So delete them! this will combine two adjacent short edges into a long one

Referenced by protocols::enzdes::EnzdesFlexibleRegion::minimize_region().

void core::kinematics::FoldTree::delete_jump_and_intervening_cutpoint ( int  jump_begin,
int  jump_end 
)

Useful for removing a loop modeling jump+cut.

Useful for removing a loop modeling jump+cut

Note:
This will trigger a renumbering of the jumps if jump number < num_jump()

References make_table_of_pilot_apps::begin, core::sequence::end, and TR().

Referenced by protocols::forge::methods::remove_cutpoint(), and protocols::forge::methods::remove_cutpoints().

void core::kinematics::FoldTree::delete_jump_and_intervening_cutpoint ( int const  jump_number)

Useful for removing a loop modeling jump+cut.

Useful for removing a loop modeling jump+cut

Note:
This will trigger a renumbering of the jumps if jump_number < num_jump()
void core::kinematics::FoldTree::delete_segment ( int const  seg_begin,
int const  seg_end 
)

Deletes a continuous segment from <seq_begin> to <seq_end>

example(s): ft.delete_segment(13,37) See also: FoldTree FoldTree.check_fold_tree FoldTree.delete_edge FoldTree.new_jump FoldTree.nres FoldTree.simple_tree

it assumes that the segment is completely contained in a single edge of the tree. Only edge_list is updated and new topology is set true. No derived data is updated.

References protocols::rigid::c2n, protocols::rigid::n2c, and TR().

void core::kinematics::FoldTree::delete_self_edges ( )

Deletes edges with start==stop allowable 1->1 edge for single residue FoldTree.

Delete self-edges in the foldtree, allowing the edge 1->1 for a single residue tree

void core::kinematics::FoldTree::delete_seqpos ( int const  seqpos)

Deletes the residue <seqpos> from the FoldTree. Will rearrange topology if necessary.

example(s): ft.delete_seqpos(3) See also: FoldTree FoldTree.check_fold_tree FoldTree.clear FoldTree.new_jump FoldTree.nres FoldTree.num_jump FoldTree.simple_tree

Delete a sequence position from a foldtree. If the residue is a jump point or the root of the tree, we will have to rearrange the topology.

Referenced by protocols::forge::methods::replace().

void core::kinematics::FoldTree::delete_unordered_edge ( int const  start,
int const  stop,
int const  label 
)

Find an edge in fold tree and delete it.

needs to match start residue number, end residue number and label index. abort if the edge is not found.

References TR().

std::string core::kinematics::FoldTree::downstream_atom ( int const  jump_number) const

the jump atom on the stopping side

Get the downstream connection atomno (connection atom # at the "stop" vertex) If it hasn't been set return 0. Also see set_jump_atoms, which sets this data.

References core::kinematics::Edge::downstream_atom(), and core::kinematics::Edge::has_atom_info().

Referenced by protocols::swa::rna::Output_fold_tree_info().

int core::kinematics::FoldTree::downstream_jump_residue ( int const  jump_number) const

the stopping residue for this jump

Get the sequence position of the downstream vertex of the jump indicated by the jump_number argument. Downstream means that if we traverse the tree starting at the root then we hit that vertex second.

return 0 if failed

Referenced by protocols::abinitio::MembraneAbinitio::add_spanning_region(), protocols::enzdes::DetectProteinLigandInterface::apply(), core::optimization::symmetry::atom_tree_get_atompairE_deriv(), protocols::enzdes::EnzdesBaseProtocol::create_enzdes_movemap(), protocols::swa::Figure_out_moving_residues(), protocols::enzdes::SecondaryMatchProtocol::find_all_allowed_positions(), core::pose::symmetry::find_symmetric_basejump_anchor(), protocols::swa::rna::floating_base_chain_closure_setup(), protocols::jumping::JumpSample::generate_jump_frags(), protocols::jumping::JumpSample::generate_jump_frames(), core::pose::get_chain_id_from_jump_id(), core::pose::get_jump_id_from_chain_id(), protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(), protocols::forge::methods::jumps_and_cuts_from_pose(), protocols::swa::rna::make_cut_at_moving_suite(), core::pose::symmetry::make_symmetric_movemap(), protocols::swa::rna::move_jump_atom_to_base(), protocols::swa::rna::Output_movemap(), protocols::enzdes::PredesignPerturbMover::parse_my_tag(), protocols::comparative_modeling::hybridize::ChunkTrialMover::pick_random_chunk(), protocols::rna::RNA_StructureParameters::random_jump_change(), protocols::rna::remove_cutpoint_closed(), protocols::simple_filters::AlaScan::report(), protocols::protein_interface_design::AlaScan::report(), core::pose::symmetry::sealed_symmetric_fold_tree(), protocols::comparative_modeling::hybridize::InsertChunkMover::set_bb_xyz_aligned(), core::conformation::symmetry::SymmetricConformation::set_dof(), protocols::analysis::InterfaceAnalyzerMover::set_pose_info(), core::pose::swap_transform(), and core::conformation::symmetry::symmetrize_fold_tree().

int core::kinematics::FoldTree::edge_label ( int const  start,
int const  stop 
)

Returns the edge label of the edge from <start> to <stop>

this is an internal function, used for testing if an edge is separating

References TR().

bool core::kinematics::FoldTree::empty ( ) const [inline]

Returns true if the FoldTree is empty.

example(s): ft.empty() See also: FoldTree FoldTree.check_fold_tree FoldTree.clear FoldTree.nres FoldTree.simple_tree FoldTree.size

Referenced by root().

const_iterator core::kinematics::FoldTree::end ( ) const [inline]
int core::kinematics::FoldTree::get_jump_that_builds_residue ( int const  seqpos) const

Get the number of the jump that builds (connects to) a given residue.

Get the number of the jump that builds (connects to) a given residue

References core::kinematics::Edge::is_jump(), and core::kinematics::Edge::label().

Referenced by core::optimization::symmetry::atom_tree_get_atompairE_deriv(), protocols::enzdes::DiversifyStoredRBConfs::diversify_all_confs(), and protocols::enzdes::MinimizeStoredRBConfs::rb_minimize_all_confs().

utility::vector1< Edge > core::kinematics::FoldTree::get_outgoing_edges ( int const  seqpos) const
int core::kinematics::FoldTree::get_polymer_residue_direction ( int const  seqpos) const

Returns the direction (n2c, c2n) in which the given (peptide) residue is built during folding.

Returns the folding direction of a given polymer (peptide) residue. If the residue is in a peptide edge this is the direction in which that edge is traveled if we traverse the tree starting at the root. Will die if residue is root or if residue is built by jump or chemical bond.

References make_table_of_pilot_apps::begin, and core::sequence::end.

Edge const & core::kinematics::FoldTree::get_residue_edge ( int const  seqpos) const
size_t core::kinematics::FoldTree::hash_value ( ) const
void core::kinematics::FoldTree::insert_fold_tree_by_jump ( FoldTree const &  subtree,
int const  insert_seqpos,
int const  insert_jumppos,
int const  anchor_pos,
int  anchor_jump_number = 0,
std::string const &  anchor_atom = "",
std::string const &  root_atom = "" 
)

Inserts a fold_tree as a subtree.

Insert another fold_tree as a subtree. Residues are inserted as a contiguous block beginning at insert_seqpos. Jumps are inserted as a contiguous block beginning at insert_jumppos. Note that insert_seqpos could be equal to nres()+1, ie subtree is being appended at the end. The jump anchoring subtree runs from the residue currently numbered "anchor_pos" to the residue insert_seqpos + subtree.root() - 1, and has label/number anchor_jump_number

References protocols::forge::methods::add_vertex(), begin(), end(), core::kinematics::Edge::is_jump(), core::kinematics::Edge::label(), nres(), num_jump(), root(), core::kinematics::Edge::start(), core::kinematics::Edge::stop(), and TR().

void core::kinematics::FoldTree::insert_polymer_residue ( int const  seqpos,
bool const  join_lower,
bool const  join_upper 
)

Inserts a polymer residue at position <seqpos> How?

(ie between current rsds seqpos-1 and seqpos, so that the sequence position of the new residue is seqpos) if seqpos-1 is a cutpoint in the current fold_tree -- we have a choice about how to connect the new residue: it could be joined to the preceding peptide segment (join to seqpos-1) or to the following segment (joined to the residue currently at seqpos). join_upper and join_lower control the behavior in this case.

Note:
seqpos may be greater than current nres, ie we may be "inserting" at end
void core::kinematics::FoldTree::insert_residue_by_jump ( int const  seqpos,
int  anchor_pos,
std::string const &  anchor_atom = "",
std::string const &  root_atom = "" 
)

Inserts a residue attached only by a jump. precondition is that seqpos-1 is a cutpoint.

Note:
that anchor_pos is wrt the current numbering system (ie before insertion)

Insert a new residue into the tree at position seqpos, anchoring it to the rest of the tree by a jump

the residue at position seqpos moves to position seqpos+1

vertices remapped, only question is cutpoint at seqpos-1, should it move to seqpos?

bool core::kinematics::FoldTree::is_cutpoint ( int const  seqpos) const [inline]

Returns true is position <seqpos> is a cutpoint.

example(s): ft.is_cutpoint(37) See also: FoldTree FoldTree.cutpoint FoldTree.new_jump FoldTree.nres FoldTree.num_cutpoint FoldTree.num_jump

Referenced by protocols::topology_broker::TopologyBroker::add_chainbreak_variants(), protocols::simple_moves::MissingDensityToJumpMover::apply(), protocols::rbsegment_relax::RBSegmentRelax::apply(), protocols::comparative_modeling::hybridize::CartesianHybridize::apply(), protocols::loops::apply_sequence_mapping(), protocols::swa::rna::apply_virtual_rna_residue_variant_type(), protocols::toolbox::AllowInsert::calculate_atom_id_map(), protocols::topology_broker::TopologyBroker::check_chainbreak_variants(), protocols::jumping::close_chainbreaks(), protocols::topology_broker::copy_internal_coords(), protocols::rna::create_rna_vall_torsions(), core::scoring::methods::ChainbreakEnergy::eval_atom_derivative(), core::scoring::methods::CartesianBondedEnergy::eval_atom_derivative(), protocols::electron_density::findLoopFromDensity(), protocols::electron_density::findLoopFromPatterson(), protocols::loops::Loops::grow_loop(), protocols::loops::Loops::grow_loop_away_from_sheets(), core::conformation::is_ideal_position(), core::scoring::methods::is_lower_cutpoint(), core::scoring::methods::is_upper_cutpoint(), core::scoring::electron_density::ElectronDensity::matchRes(), protocols::loops::loop_mover::perturb::LoopMover_Perturb_KIC::model_loop(), protocols::loops::loop_mover::perturb::LoopMover_Perturb_CCD::model_loop(), protocols::swa::possible_root(), protocols::swa::rna::possible_root(), protocols::forge::methods::remove_cutpoint(), protocols::rna::remove_cutpoints_closed(), core::scoring::methods::CartesianBondedEnergy::residue_pair_energy(), core::kinematics::simple_visualize_fold_tree(), core::kinematics::simple_visualize_fold_tree_and_movemap(), and core::kinematics::simple_visualize_fold_tree_and_movemap_bb_chi().

bool core::kinematics::FoldTree::is_jump_point ( int const  seqpos) const [inline]
bool core::kinematics::FoldTree::is_root ( int const  seqpos) const [inline]
bool core::kinematics::FoldTree::is_simple_tree ( ) const

Returns true if the FoldTree has 1-edge (non-jump)

Returns true if this tree is a simple 1->total_residue FoldTree, returns false otherwise.

example(s): ft.is_simple_tree() See also: FoldTree FoldTree.check_fold_tree FoldTree.num_jump FoldTree.simple_tree

References make_table_of_pilot_apps::begin.

Referenced by core::io::silent::BinaryRNASilentStruct::resize().

Edge const & core::kinematics::FoldTree::jump_edge ( int const  jump_number) const [inline]
Edge & core::kinematics::FoldTree::jump_edge ( int const  jump_number) [inline]

Returns the jump edge with jump number <jump_number> (non-const)

bool core::kinematics::FoldTree::jump_exists ( int const  pos1,
int const  pos2 
) const [inline]

Return true if a jump exists between <pos1> and <pos2>

example(s): ft.empty() See also: FoldTree FoldTree.check_fold_tree FoldTree.jump_edge FoldTree.new_jump FoldTree.nres

References jump_point(), and num_jump().

core::Size core::kinematics::FoldTree::jump_nr ( core::Size  upstream_res,
core::Size  downstream_res 
) const [inline]

get the jump_nr connected to jump upstream->downstream, returns 0 if not found

whether a jump exists between these residues

References jump_point(), and num_jump().

Referenced by core::pose::transfer_jumps().

int core::kinematics::FoldTree::jump_point ( int const  lower_higher,
int const  jump_number 
) const [inline]

starting or stopping residue of a jump edge

Referenced by jump_exists(), jump_nr(), and protocols::swa::rna::Output_fold_tree_info().

void core::kinematics::FoldTree::new_chemical_bond ( int const  anchor_pos,
int const  root_pos,
std::string const &  anchor_atom,
std::string const &  root_atom,
int const  new_cutpoint 
)

Add a new jump to an existing fold tree, returns the jump_number of the new jump.

References protocols::forge::methods::add_vertex(), and core::kinematics::Edge::is_chemical_bond().

int core::kinematics::FoldTree::new_jump ( int const  jump_pos1,
int const  jump_pos2,
int const  new_cutpoint 
)
Size core::kinematics::FoldTree::nres ( ) const [inline]
int core::kinematics::FoldTree::num_cutpoint ( ) const [inline]
Size core::kinematics::FoldTree::num_jump ( ) const [inline]

Returns the number of jumps in the FoldTree.

example(s): ft.num_jump() See also: FoldTree FoldTree.check_fold_tree FoldTree.jump_edge FoldTree.new_jump FoldTree.nres

Referenced by protocols::toolbox::pose_manipulation::add_chainbreaks_according_to_jumps(), protocols::toolbox::pose_metric_calculators::append_rsd_by_jump_near_atom(), protocols::toolbox::pose_metric_calculators::dock_waters_to_atom(), protocols::swa::Figure_out_moving_residues(), core::io::silent::RNA_SilentStruct::fill_pose(), core::io::silent::BinaryProteinSilentStruct::fill_pose(), core::io::silent::RNA_SilentStruct::fill_struct(), core::io::silent::BinaryRNASilentStruct::fill_struct(), core::io::silent::BinaryProteinSilentStruct::fill_struct(), protocols::forge::methods::find_connecting_jump(), core::pose::symmetry::find_symmetric_basejump_anchor(), protocols::swa::rna::floating_base_chain_closure_setup(), core::conformation::symmetry::SymmetricConformation::fold_tree(), protocols::loops::fold_tree_from_loops(), core::conformation::get_root_residue_root_atomno(), core::io::silent::BinaryRNASilentStruct::init_from_lines(), core::io::silent::BinaryProteinSilentStruct::init_from_lines(), core::conformation::symmetry::SymmetricConformation::insert_conformation_by_jump(), insert_fold_tree_by_jump(), jump_exists(), jump_nr(), protocols::forge::methods::jumps_and_cuts_from_pose(), protocols::swa::rna::make_cut_at_moving_suite(), protocols::forge::methods::merge(), protocols::enzdes::EnzdesFlexibleRegion::minimize_region(), protocols::swa::rna::Output_movemap(), core::io::silent::RNA_SilentStruct::print_conformation(), core::io::silent::BinaryRNASilentStruct::print_conformation(), core::io::silent::BinaryProteinSilentStruct::print_conformation(), protocols::toolbox::pose_manipulation::remove_chainbreaks_according_to_jumps(), protocols::rna::remove_cutpoint_closed(), core::pose::symmetry::sealed_symmetric_fold_tree(), protocols::toolbox::pose_metric_calculators::SemiExplicitWaterUnsatisfiedPolarsCalculator::semiexpl_water_hbgeom_score(), core::conformation::symmetry::setup_symmetric_conformation(), core::kinematics::ShortestPathInFoldTree::ShortestPathInFoldTree(), core::kinematics::simple_visualize_fold_tree(), core::kinematics::simple_visualize_fold_tree_and_movemap(), core::kinematics::simple_visualize_fold_tree_and_movemap_bb_chi(), and core::conformation::symmetry::symmetrize_fold_tree().

FoldTree& core::kinematics::FoldTree::operator= ( FoldTree const &  src) [inline]

operator=

Note:
this version doesnt copy any of the derived data! will this be too slow? it will trigger re-calculating of everything every time we reject a move....
void core::kinematics::FoldTree::partition_by_jump ( int const  jump_number,
FoldTree f1,
FoldTree f2 
) const

partition into two foldtrees by cutting at jump= jump_number

Create two new foldtrees f1 and f2 by splitting myself at jump jump_number Uses the following routine to figure out which vertices should be in each tree.

Note:
The N-terminal vertex of jump "jump_number" goes to tree f1

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

Referenced by protocols::protein_interface_design::movers::DesignMinimizeHbonds::apply(), protocols::protein_interface_design::movers::BackrubDDMover::apply(), protocols::coarse_rna::CoarseRNA_LoopCloser::apply_after_jump_change(), core::scoring::sc::ShapeComplementarityCalculator::Calc(), protocols::docking::calc_Fnat(), protocols::docking::calc_Lrmsd(), protocols::geometry::centroids_by_jump(), protocols::geometry::centroids_by_jump_int(), protocols::ligand_docking::LigandBaseProtocol::find_interface_backbone(), protocols::ligand_docking::LigandBaseProtocol::find_interface_rsds(), core::pack::task::operation::util::find_jump_partners_within_CB_cutoff(), protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(), core::pose::partition_pose_by_jump(), protocols::rna::remove_cutpoint_closed(), protocols::simple_filters::EnergyPerResidueFilter::report(), protocols::protein_interface_design::EnergyPerResidueFilter::report(), protocols::enzdes::LigInterfaceEnergyFilter::report(), and protocols::simple_moves::DesignRepackMover::setup_packer_and_movemap().

void core::kinematics::FoldTree::partition_by_jump ( int const  jump_number,
ObjexxFCL::FArray1D_bool &  partner1 
) const

partition the fold tree in two parts if the jump is disconnected.

void core::kinematics::FoldTree::partition_by_residue ( int const  seqpos,
ObjexxFCL::FArray1D_bool &  partner1 
) const

partition the fold tree in two parts if a cut would be introduced between seqpos and seqpos+1

partition the fold tree in two parts if a cut would be introduced between seqpos and seqpos+1. Function is an analog to partition_by_jump() -- its goal to find all residues connecting to the jump starting residue and flag them in the partner1(n_res) array as true. The residues on the other side are flagged as false. Useful to distinguish two docking partners when fold tree is properly set up.void

References make_table_of_pilot_apps::begin, core::sequence::end, core::kinematics::Edge::start(), and core::kinematics::Edge::stop().

Referenced by protocols::coarse_rna::CoarseRNA_LoopCloser::apply().

void core::kinematics::FoldTree::put_jump_stubs_intra_residue ( )
bool core::kinematics::FoldTree::random_tree_from_jump_points ( int const  nres_in,
int const  num_jump_in,
ObjexxFCL::FArray2D_int const &  jump_point,
std::vector< int > const &  obligate_cut_points,
ObjexxFCL::FArray1D_float const &  cut_bias,
int const  root_in = 1,
bool const  allow_jump_at_1_or_NRES = false 
)

Builds a FoldTree from a list of <jump_points> and random cut points based on some biased probability and any user-defined obligate cutpoints Returns bool about success.

bool core::kinematics::FoldTree::random_tree_from_jump_points ( int const  nres_in,
int const  num_jump_in,
ObjexxFCL::FArray2D_int const &  jump_point,
ObjexxFCL::FArray1D_float const &  cut_bias,
int const  root_in = 1,
bool const  allow_jump_at_1_or_NRES = false 
)

Builds a FoldTree from a list of <jump_points> and random cut points based on some biased probability Returns bool about success.

Referenced by protocols::abinitio::LoopJumpFoldCst::add_rigidity_jumps(), and protocols::jumping::MembraneJump::setup_fold_tree().

void core::kinematics::FoldTree::reassign_atoms_for_intra_residue_stubs ( )

this reorganizes upstream/downstream atoms of jumps that have flag keep_stub_in_resiue = true such that stubs are N-CA-C

References core::kinematics::Edge::is_jump(), core::kinematics::Edge::start(), core::kinematics::Edge::stop(), strip_whitespace(), and TR().

void core::kinematics::FoldTree::renumber_jumps ( )

Renumbers the jump edges in the FoldTree How?

Assign new numbers to the jumps. after we delete a jump, we may want to re-number the others. note of course this will invalidate the jump_transform array of any pose with this fold_tree, so be sure to call jumps_from_positions or something

References TR().

Referenced by core::conformation::symmetry::get_asymm_unit_fold_tree().

bool core::kinematics::FoldTree::reorder ( int const  start_residue)
int core::kinematics::FoldTree::root ( ) const [inline]
void core::kinematics::FoldTree::set_jump_atoms ( int const  jump_number,
std::string const &  upstream_atom,
std::string const &  downstream_atom,
bool  bKeepStubInResidue = false 
)

define the specific atoms that should be connected by this jump

This information can then be used in setting up the AtomTree from the FoldTree. Data is stored in the Edge corresponding to this Jump. If not specified, residue-specific defaults will be used.

Set connection atoms for a jump. This is not used by the foldtree, only to communicate to the AtomTree during construction of an atomtree from a foldtree.

References core::kinematics::Edge::downstream_atom(), core::kinematics::Edge::keep_stub_in_residue(), and core::kinematics::Edge::upstream_atom().

Referenced by protocols::rna::RNA_HelixAssembler::apply(), protocols::frag_picker::nonlocal::NonlocalFrags::apply(), protocols::rna::figure_out_reasonable_rna_fold_tree(), and protocols::swa::rna::move_jump_atom_to_base().

void core::kinematics::FoldTree::set_jump_atoms ( int const  jump_number,
core::Size  res1,
std::string const &  atom1,
core::Size  res2,
std::string const &  atom2,
bool  bKeepStubInResidue = false 
)
void core::kinematics::FoldTree::show ( std::ostream &  out) const

Displays the FoldTree information.

example(s): ft.show() See Also: Pose

References make_table_of_pilot_apps::begin, and core::sequence::end.

void core::kinematics::FoldTree::simple_tree ( int const  nres_in)
int core::kinematics::FoldTree::size ( ) const [inline]
void core::kinematics::FoldTree::slide_cutpoint ( Size const  current_cut,
Size const  target_cut 
)

Slide a polymer cutpoint from one location to another.

Slide a cutpoint from one position to another.

References protocols::forge::methods::add_vertex(), and TR().

void core::kinematics::FoldTree::slide_jump ( Size const  jump_number,
Size const  new_res1,
Size const  new_res2 
)

change an existing jump to start and end in new positions

Switches a given jump to connect two different residues.

References make_table_of_pilot_apps::begin, core::sequence::end, and TR().

bool core::kinematics::FoldTree::tree_from_jumps_and_cuts ( int const  nres_in,
int const  num_jump_in,
ObjexxFCL::FArray2D_int const &  jump_point,
ObjexxFCL::FArray1D_int const &  cuts,
int const  root_in = 1,
bool const  verbose = false 
)

Constructs a FoldTree from listed <jump point>=""> and <cuts> Returns bool about success.

Construct a new tree (self) from a set of jump points and cutpoints this assumes that we can make a tree, ie that the number of cuts is equal to the number of jumps.

Note:
The root vertex of new tree is 1.

References TR().

Referenced by protocols::loops::apply_sequence_mapping(), core::fragment::make_simple_fold_tree_from_jump_frame(), protocols::rna::remove_cutpoint_closed(), core::pose::symmetry::sealed_symmetric_fold_tree(), protocols::anchored_design::AnchoredDesignMover::set_fold_tree_and_cutpoints(), protocols::nonlocal::StarTreeBuilder::set_up(), and core::conformation::symmetry::symmetrize_fold_tree().

void core::kinematics::FoldTree::update_edge_label ( int const  start,
int const  stop,
int const  old_label,
int const  new_label 
)

Changes the label of an edge in fold tree.

this is an internal function, used for testing if an edge is separating

References TR().

std::string core::kinematics::FoldTree::upstream_atom ( int const  jump_number) const

the jump atom on the staring side

Get the upstream connection resid (connection atom # at the "start" vertex) If it hasn't been set return 0. Also see set_jump_atoms, which sets this data.

References core::kinematics::Edge::has_atom_info(), and core::kinematics::Edge::upstream_atom().

Referenced by protocols::swa::rna::Output_fold_tree_info().

int core::kinematics::FoldTree::upstream_jump_residue ( int const  jump_number) const

Friends And Related Function Documentation

bool operator!= ( const FoldTree a,
const FoldTree b 
) [friend]

Not equal to operator.

std::ostream& operator<< ( std::ostream &  os,
FoldTree const &  t 
) [friend]

output operator

Foldtree output to stream

bool operator== ( FoldTree const &  a,
FoldTree const &  b 
) [friend]

equal to operator

Checks that edges are in the same order and are equal

std::istream& operator>> ( std::istream &  is,
FoldTree t 
) [friend]

input operator

Foldtree input from stream


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