Rosetta 3.4
Functions
protocols::forge::methods Namespace Reference

Functions

core::Real linear_chainbreak (core::pose::Pose const &pose, core::Size const pos)
 evaluate linear chainbreak at a position
core::Real linear_chainbreak (core::pose::Pose &pose, core::Size const pos)
 evaluate linear chainbreak at a position
core::Real overlap_chainbreak (core::pose::Pose const &pose, core::Size const pos)
 evaluate overlap chainbreak at a position
core::Real overlap_chainbreak (core::pose::Pose &pose, core::Size const pos)
 evaluate overlap chainbreak at a position
core::Real quadratic_chainbreak (core::pose::Pose const &pose, core::Size const pos)
 evaluate quadratic chainbreak at a position
core::Real quadratic_chainbreak (core::pose::Pose &pose, core::Size const pos)
 evaluate quadratic chainbreak at a position
static
numeric::random::RandomGenerator 
RG (2557316)
static basic::Tracer TR ("protocols.forge.methods.fold_tree_functions")
bool order (core::kinematics::Edge &e)
 enforce Edge has start <= stop (swap if necessary)
core::Size closest_larger_peptide_vertex (core::Size const v, core::kinematics::FoldTree const &ft, core::Size const k)
 find the k'th closest larger peptide vertex of given vertex in fold tree
core::Size closest_smaller_peptide_vertex (core::Size const v, core::kinematics::FoldTree const &ft, core::Size const k)
 find the k'th closest smaller peptide vertex of given vertex in fold tree
bool vertex_exists (core::Size const v, core::kinematics::FoldTree const &ft)
 query if vertex already exists in fold tree
utility::vector1
< core::kinematics::Edge
jumps_connected_to_position (core::Size const pos, core::kinematics::FoldTree const &ft)
 find all jump edges whose start or stop lands on the given position
core::Size find_connecting_jump (core::Size const u, core::Size const v, core::kinematics::FoldTree const &ft)
 find the jump connecting two continuous segments of a fold tree
bool remove_cutpoint (core::Size const v, core::kinematics::FoldTree &ft)
 remove a cutpoint, merging the two sections that are adjacent to the cut
void remove_cutpoints (utility::vector1< core::Size > const &cutpoints, core::kinematics::FoldTree &ft)
 seal a fold tree by removing all specified cutpoints
core::kinematics::FoldTree shift_jumps (core::kinematics::FoldTree const &ft, core::kinematics::MoveMap const &mm)
 attempt to shift jumps in a fold tree based on fixed positions in a MoveMap
core::kinematics::FoldTree fold_tree_from_pose (core::pose::Pose const &pose, core::Size const ft_root, core::kinematics::MoveMap const &mm)
 construct a fold tree from Pose wrt chain endings and residue types
core::kinematics::FoldTree merge (core::kinematics::FoldTree const &left_tree, core::kinematics::FoldTree const &right_tree)
 merge two fold trees by jump between their roots
core::kinematics::FoldTree merge (core::kinematics::FoldTree const &left_tree, core::Size const left_position, core::kinematics::FoldTree const &right_tree, core::Size const right_position)
 merge two fold trees connecting by jump via specified positions
core::kinematics::FoldTree merge (core::kinematics::FoldTree const &left_tree, core::Size const left_position, std::string const &left_jump_atom, core::kinematics::FoldTree const &right_tree, core::Size const right_position, std::string const &right_jump_atom, bool const keep_stub_in_residue)
 merge two fold trees connecting by jump via specified positions
core::kinematics::FoldTree replace (core::kinematics::FoldTree const &original_tree, int const replace_begin, int const replace_end, core::kinematics::MoveMap const &movemap, core::kinematics::FoldTree const &replacement_tree)
 replace a section of one fold tree with another fold tree, connecting by jump between their roots
void make_star_foldtree (core::pose::Pose &pose, protocols::loops::Loops loops)
void jumps_and_cuts_from_pose (core::pose::Pose &pose, utility::vector1< std::pair< core::Size, core::Size > > &jumps, utility::vector1< core::Size > &cuts)
template<typename EdgeIterator >
void add_edges (EdgeIterator begin, EdgeIterator end, core::kinematics::FoldTree &ft)
 add a set of Edges to a FoldTree
template<typename EdgeIterator >
EdgeIterator regular_facet_containing_position (core::Size const pos, EdgeIterator const begin, EdgeIterator const end)
 find regular facet (non-jump edge sans face vertices) that contains given position
template<typename EdgeList >
bool add_vertex (core::Size const v, EdgeList &edges)
 add a vertex, splitting edges if necessary
template<typename EdgeIterator >
EdgeIterator facet_containing_position (core::Size const pos, EdgeIterator const begin, EdgeIterator const end, int const label=core::kinematics::Edge::PEPTIDE)
 find facet (edge sans face vertices) that contains given position
template<typename EdgeIterator >
utility::vector1
< core::kinematics::Edge
regular_edges_within_interval (core::Size const left, core::Size const right, EdgeIterator const begin, EdgeIterator const end)
 find regular (non-jump) edges contained within the interval [left, right]
template<typename EdgeIterator >
utility::vector1
< core::kinematics::Edge
edges_within_interval (core::Size const left, core::Size const right, int const edge_type, EdgeIterator const begin, EdgeIterator const end)
 find specific type of edges contained within the interval [left, right]
core::fragment::ConstantLengthFragSetOP smallmer_from_largemer (core::fragment::FrameIterator begin, core::fragment::FrameIterator end, core::Size const smallmer_size, bool const all_possible_smallmers)
 create small-mers from large-mers
static basic::Tracer TR ("protocols.forge.methods.pose_mod")
bool add_cutpoint_variants (core::pose::Pose &pose, core::Size const pos)
 add cutpoint variants at a specific position
bool remove_cutpoint_variants (core::pose::Pose &pose, core::Size const pos)
 remove cutpoint variants at a specific position
void restore_residues (std::map< core::Size, core::Size > const &old2new, core::pose::Pose &archive_pose, core::pose::Pose &pose)
 restore residues (i.e. sidechains)
void restore_residues (core::pose::Pose &archive_pose, core::pose::Pose &pose)
 restore residues (i.e. sidechains)
template<typename ResidueOPIterator >
core::Size grow_left_r (core::pose::Pose &pose, core::Size anchor, ResidueOPIterator begin, ResidueOPIterator end, bool const correct_terminus=true, bool const use_existing_crd=false)
 grow a series of residues to the left of a position
template<typename ResidueTypeOPIterator >
core::Size grow_left_rtype (core::pose::Pose &pose, core::Size anchor, ResidueTypeOPIterator begin, ResidueTypeOPIterator end, bool const correct_terminus=true)
 grow a series of residues to the left of a position
template<typename ResidueOPIterator >
core::Size grow_right_r (core::pose::Pose &pose, core::Size anchor, ResidueOPIterator begin, ResidueOPIterator end, bool const correct_terminus=true, bool const use_existing_crd=false)
 grow a series of residues to the right of a position
template<typename ResidueTypeOPIterator >
core::Size grow_right_rtype (core::pose::Pose &pose, core::Size anchor, ResidueTypeOPIterator begin, ResidueTypeOPIterator end, bool const correct_terminus=true)
 grow a series of residues to the right of a position
static basic::Tracer TR ("protocols.forge.methods.util")
static
numeric::random::RandomGenerator 
RG (2211990)
void union_interval (core::Size const root, core::Size const left, core::Size const right, core::graph::DisjointSets &uf)
 perform union( root, i ) for all 'i' within the closed interval [left, right]
core::Size find_cutpoint (core::pose::Pose const &pose, core::Size left, core::Size right)
 moving left to right, find the first true cutpoint within specified extent
core::Size count_cutpoints (core::pose::Pose const &pose, core::Size left, core::Size right)
 moving left to right, count the number of true cutpoints within the specified extent
void trans_omega (core::Size const left, core::Size const right, core::pose::Pose &pose)
 set omega to 180 for a range of residues [left, right]
protocols::loops::Loop interval_to_loop (protocols::forge::build::Interval const &interval)
 create Loop object w/ random cutpoint from an Interval
core::kinematics::FoldTree fold_tree_from_loops (core::pose::Pose const &pose, protocols::loops::Loops const &loops)
 create fold tree from loops
void set_single_loop_fold_tree (core::pose::Pose &pose, protocols::loops::Loop const &loop)
 set a single loop fold tree
utility::vector1< boolparse_resfile_string_with_no_lockdown (core::pose::Pose const &pose, core::pack::task::PackerTask &the_task, std::string const &resfile_string)
core::pack::task::TaskFactoryOP remodel_generic_taskfactory ()
void fill_non_loop_cst_set (core::pose::Pose &pose, protocols::loops::Loops loops)
void fixH (core::pose::Pose &pose)
void cyclize_pose (core::pose::Pose &pose)
template<typename T >
std::set< T > closed_range (T const left, T const right, T const increment=1)
 return a set containing values in the closed interval [left, right] filled by looping from left -> right with the given increment
template<typename T >
void insert_closed_range (T const left, T const right, std::set< T > &s, T const increment=1)
 add the values in the closed interval [left, right] to a set by looping from left -> right with the given increment
template<typename T >
std::set< T > half_open_range (T const left, T const right, T const increment=1)
 return a set containing values in the half-open interval [left, right) filled by looping from left -> right with the given increment
template<typename T >
void insert_half_open_range (T const left, T const right, std::set< T > &s, T const increment=1)
 add the values in the half-open interval [left, right) to a set by looping from left -> right with the given increment
template<typename IntervalIterator >
protocols::loops::Loops intervals_to_loops (IntervalIterator begin, IntervalIterator end)
 create Loops object w/ random cutpoints from a collection of Intervals
template<typename IntervalIterator >
protocols::loops::Loops intervals_to_confirmation_loops (IntervalIterator begin, IntervalIterator end, core::Size nres)
 create Loops object w/ random cutpoints from a collection of Intervals for KIC confirmation purpose

Function Documentation

bool protocols::forge::methods::add_cutpoint_variants ( core::pose::Pose pose,
core::Size const  pos 
)

add cutpoint variants at a specific position

Parameters:
[in,out]Poseto modify
[in]positionat which to add cutpoint variants
Returns:
true if cutpoint variants added, false if position not a topological cutpoint or cutpoint variants already exist
Parameters:
[in,out]Poseto modify
[in]positionat which to add cutpoint variants
Returns:
true if cutpoint variants added, false if position not a topological cutpoint

References core::pose::add_variant_type_to_pose_residue(), core::chemical::CUTPOINT_LOWER, core::chemical::CUTPOINT_UPPER, core::pose::Pose::fold_tree(), core::conformation::Residue::has_variant_type(), core::pose::Pose::n_residue(), and core::pose::Pose::residue().

Referenced by linear_chainbreak(), overlap_chainbreak(), and quadratic_chainbreak().

template<typename EdgeIterator >
void protocols::forge::methods::add_edges ( EdgeIterator  begin,
EdgeIterator  end,
core::kinematics::FoldTree ft 
)

add a set of Edges to a FoldTree

Parameters:
[in]beginiterator pointing to the first edge to add
[in]enditerator pointing just past the last edge to add
outft the FoldTree to modify

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

template<typename EdgeList >
bool protocols::forge::methods::add_vertex ( core::Size const  v,
EdgeList &  edges 
)
template<typename T >
std::set< T > protocols::forge::methods::closed_range ( T const  left,
T const  right,
T const  increment = 1 
)
core::Size protocols::forge::methods::closest_larger_peptide_vertex ( core::Size const  v,
core::kinematics::FoldTree const &  ft,
core::Size const  k 
)

find the k'th closest larger peptide vertex of given vertex in fold tree

Parameters:
[in]vthe given vertex
[in]ftfold tree to search
[in]kfind the k'th closest, must be > 0
Returns:
0 if no such vertex

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

Referenced by protocols::forge::build::SegmentRebuild::modify_impl().

core::Size protocols::forge::methods::closest_smaller_peptide_vertex ( core::Size const  v,
core::kinematics::FoldTree const &  ft,
core::Size const  k 
)

find the k'th closest smaller peptide vertex of given vertex in fold tree

Parameters:
[in]vthe given vertex
[in]ftfold tree to search
[in]kfind the k'th closest, must be > 0
Returns:
0 if no such vertex

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

Referenced by protocols::forge::build::SegmentRebuild::modify_impl().

core::Size protocols::forge::methods::count_cutpoints ( core::pose::Pose const &  pose,
core::Size  left,
core::Size  right 
)

moving left to right, count the number of true cutpoints within the specified extent

0, pose.n_residue(), and any cutpoint with lower/upper terminus are not counted as cutpoints

References core::pose::Pose::fold_tree(), core::conformation::Residue::is_lower_terminus(), core::conformation::Residue::is_upper_terminus(), core::pose::Pose::n_residue(), and core::pose::Pose::residue().

Referenced by protocols::forge::components::VarLengthBuild::centroid_build().

void protocols::forge::methods::cyclize_pose ( core::pose::Pose pose)
template<typename EdgeIterator >
utility::vector1< core::kinematics::Edge > protocols::forge::methods::edges_within_interval ( core::Size const  left,
core::Size const  right,
int const  edge_type,
EdgeIterator const  begin,
EdgeIterator const  end 
)

find specific type of edges contained within the interval [left, right]

References core::sequence::end, and order().

template<typename EdgeIterator >
EdgeIterator protocols::forge::methods::facet_containing_position ( core::Size const  pos,
EdgeIterator const  begin,
EdgeIterator const  end,
int const  label = core::kinematics::Edge::PEPTIDE 
)

find facet (edge sans face vertices) that contains given position

Parameters:
[in]posposition
[in]beginiterator pointing to the first edge to search
[in]enditerator pointing just past the last edge to search
[in]labelthe types of Edge to search, default PEPTIDE
Returns:
iterator pointing to the Edge defining the facet that contains the position; if vertex lies on the face of an edge or vertex not found, returns 'end'

References core::sequence::end.

Referenced by merge(), and replace().

void protocols::forge::methods::fill_non_loop_cst_set ( core::pose::Pose pose,
protocols::loops::Loops  loops 
)
core::Size protocols::forge::methods::find_connecting_jump ( core::Size const  u,
core::Size const  v,
core::kinematics::FoldTree const &  ft 
)

find the jump connecting two continuous segments of a fold tree

Parameters:
[in]uAny vertex on the first segment.
[in]vAny vertex on the second segment.
[in]ftThe fold tree to query.
Returns:
the jump number connecting the two segments, 0 if no such jump

References core::kinematics::FoldTree::begin(), core::kinematics::FoldTree::end(), core::kinematics::FoldTree::jump_edge(), core::kinematics::FoldTree::nres(), core::kinematics::FoldTree::num_jump(), order(), and union_interval().

Referenced by protocols::forge::build::SegmentRebuild::modify_impl(), and protocols::forge::build::SegmentInsert::modify_impl().

core::Size protocols::forge::methods::find_cutpoint ( core::pose::Pose const &  pose,
core::Size  left,
core::Size  right 
)

moving left to right, find the first true cutpoint within specified extent

moving left to right, find the first true cutpoint within the specified extent

Returns:
the cutpoint position, otherwise 0 if not found

0, pose.n_residue(), and any cutpoint with lower/upper terminus are not counted as cutpoints

Returns:
the cutpoint position, otherwise 0 if not found

References core::pose::Pose::fold_tree(), core::conformation::Residue::is_lower_terminus(), core::conformation::Residue::is_upper_terminus(), core::pose::Pose::n_residue(), and core::pose::Pose::residue().

Referenced by protocols::forge::components::VarLengthBuild::centroid_build(), and protocols::forge::build::SegmentInsert::modify_impl().

void protocols::forge::methods::fixH ( core::pose::Pose pose)
core::kinematics::FoldTree protocols::forge::methods::fold_tree_from_loops ( core::pose::Pose const &  pose,
protocols::loops::Loops const &  loops 
)

create fold tree from loops

Remarks:
This is a generic replacement function for the one in protocols::loops and will be moved there in the near future.

References core::chemical::aa_vrt, core::id::BB, protocols::loops::Loops::begin(), core::conformation::Conformation::chain_begin(), core::conformation::Conformation::chain_end(), core::id::CHI, core::pose::Pose::conformation(), protocols::loops::Loop::cut(), protocols::loops::Loops::end(), core::pose::Pose::fold_tree(), fold_tree_from_pose(), core::pose::Pose::n_residue(), core::conformation::Conformation::num_chains(), core::pose::Pose::residue(), RG(), protocols::loops::Loop::start(), protocols::loops::Loop::stop(), and protocols::loops::Loops::switch_movemap().

Referenced by protocols::rbsegment_relax::RBSegmentRelax::apply(), protocols::protein_interface_design::movers::LoopRemodel::apply(), protocols::protein_interface_design::movers::LoopMoverFromCommandLine::apply(), protocols::LoopRefine::apply(), protocols::dna::DesignProteinBackboneAroundDNA::apply(), protocols::comparative_modeling::LoopRelaxMover::apply(), protocols::forge::remodel::RemodelMover::confirm_sequence(), protocols::abinitio::AbrelaxApplication::fold(), protocols::comparative_modeling::hybridize::HybridizeProtocol::initialize_and_sample_loops(), protocols::forge::remodel::RemodelLoopMover::insert_random_smallestmer_per_loop(), protocols::protein_interface_design::movers::PlaceOnLoop::minimize_toward_stub(), protocols::forge::remodel::RemodelLoopMover::randomize_stage(), protocols::docking::DockingHighResLegacy::set_dock_mcm_protocol(), set_single_loop_fold_tree(), and protocols::forge::remodel::RemodelLoopMover::simultaneous_stage().

core::kinematics::FoldTree protocols::forge::methods::fold_tree_from_pose ( core::pose::Pose const &  pose,
core::Size const  ft_root,
core::kinematics::MoveMap const &  mm 
)

construct a fold tree from Pose wrt chain endings and residue types

Remarks:
Determines edge types from residues (polymer vs non-polymer). Each chain will end up as one edge in the fold tree. Jumps will be made from the new root to a random fixed backbone residue as specified by the movemap. If all residues in a chain are moveable, will choose any random residue.
Parameters:
[in]posePose.
[in]ft_rootRoot of the new fold tree.
[in]mmMoveMap used to select jump positions.
Returns:
fold tree wrt chain endings and residue types

References core::conformation::Residue::atom_name(), core::pack::dunbrack::c, core::conformation::Residue::chain(), core::conformation::Conformation::chain_begin(), core::conformation::Conformation::chain_end(), core::pose::Pose::conformation(), core::conformation::Residue::connect_atom(), core::conformation::Residue::connected_residue_at_resconn(), core::graph::DisjointSets::ds_union(), core::kinematics::MoveMap::get_bb(), core::conformation::Residue::is_polymer(), core::pose::Pose::n_residue(), core::conformation::Residue::n_residue_connections(), core::conformation::Conformation::num_chains(), core::pose::Pose::residue(), RG(), and TR().

Referenced by protocols::forge::remodel::RemodelLoopMover::apply(), protocols::forge::components::VarLengthBuild::apply(), fold_tree_from_loops(), linear_chainbreak(), overlap_chainbreak(), quadratic_chainbreak(), and protocols::fldsgn::CircularPermutation::split_chains().

template<typename ResidueOPIterator >
core::Size protocols::forge::methods::grow_left_r ( core::pose::Pose pose,
core::Size  anchor,
ResidueOPIterator  begin,
ResidueOPIterator  end,
bool const  correct_terminus = true,
bool const  use_existing_crd = false 
)

grow a series of residues to the left of a position

Parameters:
[in,out]posePose the pose to modify
[in]anchorthe anchor position
[in]beginiterator that points to the first ResidueOP
[in]enditerator that points just beyond the last ResidueOP
[in]correct_terminusre-add lower terminus if found, default true
[in]use_existing_crdNo idealization: place residues with existing coordinates, default false.
Returns:
the left endpoint of the new growth or zero if nothing to do
Remarks:
Use a reverse iterator to grow right -> left along vector containers.

References core::pose::add_lower_terminus_type_to_pose_residue(), core::pose::Pose::conformation(), core::sequence::end, core::conformation::Residue::is_lower_terminus(), core::pose::Pose::residue(), and core::conformation::Conformation::safely_prepend_polymer_residue_before_seqpos().

Referenced by grow_left_rtype(), and protocols::forge::build::SegmentInsert::modify_impl().

template<typename ResidueTypeOPIterator >
core::Size protocols::forge::methods::grow_left_rtype ( core::pose::Pose pose,
core::Size  anchor,
ResidueTypeOPIterator  begin,
ResidueTypeOPIterator  end,
bool const  correct_terminus = true 
)

grow a series of residues to the left of a position

Parameters:
[in,out]posePose the pose to modify
[in]anchorthe anchor position
[in]beginiterator that points to the first ResidueTypeOP
[in]enditerator that points just beyond the last ResidueTypeOP
[in]correct_terminusre-add lower terminus if found, default true
Returns:
the left endpoint of the new growth or zero if nothing to do
Remarks:
Use a reverse iterator to grow right -> left along vector containers.

References core::conformation::ResidueFactory::create_residue(), core::sequence::end, and grow_left_r().

Referenced by protocols::forge::build::SegmentRebuild::modify_impl(), protocols::forge::build::SegmentInsert::modify_impl(), and protocols::forge::build::GrowLeft::modify_impl().

template<typename ResidueOPIterator >
core::Size protocols::forge::methods::grow_right_r ( core::pose::Pose pose,
core::Size  anchor,
ResidueOPIterator  begin,
ResidueOPIterator  end,
bool const  correct_terminus = true,
bool const  use_existing_crd = false 
)

grow a series of residues to the right of a position

Parameters:
[in,out]posePose the pose to modify
[in]anchorthe anchor position, can be 0 if operating on empty Pose
[in]beginiterator that points to the first ResidueOP
[in]enditerator that points just beyond the last ResidueOP
[in]correct_terminusre-add upper terminus if found, default true
[in]use_existing_crdNo idealization: place residues with existing coordinates, default false.
Returns:
the right endpoint of the new growth or zero if nothing to do

References core::pose::add_upper_terminus_type_to_pose_residue(), core::pose::Pose::append_residue_by_bond(), make_table_of_pilot_apps::begin, core::pose::Pose::conformation(), core::sequence::end, core::conformation::Residue::is_upper_terminus(), core::pose::Pose::residue(), and core::conformation::Conformation::safely_append_polymer_residue_after_seqpos().

Referenced by grow_right_rtype(), and protocols::forge::build::SegmentInsert::modify_impl().

template<typename ResidueTypeOPIterator >
core::Size protocols::forge::methods::grow_right_rtype ( core::pose::Pose pose,
core::Size  anchor,
ResidueTypeOPIterator  begin,
ResidueTypeOPIterator  end,
bool const  correct_terminus = true 
)

grow a series of residues to the right of a position

Parameters:
[in,out]posePose the pose to modify
[in]anchorthe anchor position, can be 0 if operating on empty Pose
[in]beginiterator that points to the first ResidueTypeOP
[in]enditerator that points just beyond the last ResidueTypeOP
[in]correct_terminusre-add upper terminus if found, default true
Returns:
the right endpoint of the new growth or zero if nothing to do

References core::conformation::ResidueFactory::create_residue(), core::sequence::end, and grow_right_r().

Referenced by protocols::forge::build::SegmentRebuild::modify_impl(), protocols::forge::build::SegmentInsert::modify_impl(), and protocols::forge::build::GrowRight::modify_impl().

template<typename T >
std::set< T > protocols::forge::methods::half_open_range ( T const  left,
T const  right,
T const  increment = 1 
)

return a set containing values in the half-open interval [left, right) filled by looping from left -> right with the given increment

References core::pack::interaction_graph::T().

template<typename T >
void protocols::forge::methods::insert_closed_range ( T const  left,
T const  right,
std::set< T > &  s,
T const  increment = 1 
)
template<typename T >
void protocols::forge::methods::insert_half_open_range ( T const  left,
T const  right,
std::set< T > &  s,
T const  increment = 1 
)

add the values in the half-open interval [left, right) to a set by looping from left -> right with the given increment

References core::pack::interaction_graph::T().

protocols::loops::Loop protocols::forge::methods::interval_to_loop ( protocols::forge::build::Interval const &  interval)

create Loop object w/ random cutpoint from an Interval

References protocols::forge::build::Interval::left, RG(), and protocols::forge::build::Interval::right.

Referenced by intervals_to_loops().

template<typename IntervalIterator >
protocols::loops::Loops protocols::forge::methods::intervals_to_confirmation_loops ( IntervalIterator  begin,
IntervalIterator  end,
core::Size  nres 
)

create Loops object w/ random cutpoints from a collection of Intervals for KIC confirmation purpose

References protocols::loops::Loops::add_loop(), and core::sequence::end.

Referenced by protocols::forge::remodel::RemodelMover::confirm_sequence().

template<typename IntervalIterator >
protocols::loops::Loops protocols::forge::methods::intervals_to_loops ( IntervalIterator  begin,
IntervalIterator  end 
)

create Loops object w/ random cutpoints from a collection of Intervals

References protocols::loops::Loops::add_loop(), core::sequence::end, and interval_to_loop().

void protocols::forge::methods::jumps_and_cuts_from_pose ( core::pose::Pose pose,
utility::vector1< std::pair< core::Size, core::Size > > &  jumps,
utility::vector1< core::Size > &  cuts 
)
utility::vector1< core::kinematics::Edge > protocols::forge::methods::jumps_connected_to_position ( core::Size const  pos,
core::kinematics::FoldTree const &  ft 
)

find all jump edges whose start or stop lands on the given position

Parameters:
[in]posThe position.
[in]ftThe fold tree.
Returns:
a list of jump edges
Parameters:
[in]posThe position.
[in]ftThe fold tree.
Returns:
a list of jump edges
Remarks:
jump edges start/stop will be ordered such that 'pos' will always be at 'start'.

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

Referenced by protocols::forge::build::SegmentRebuild::modify_impl().

core::Real protocols::forge::methods::linear_chainbreak ( core::pose::Pose const &  pose,
core::Size const  pos 
)

evaluate linear chainbreak at a position

Remarks:
Copies the Pose, if necessary swaps the Pose with a cut fold tree, then evaluates the chainbreak.

References core::pose::Pose::fold_tree(), fold_tree_from_pose(), and core::kinematics::FoldTree::new_jump().

Referenced by linear_chainbreak().

core::Real protocols::forge::methods::linear_chainbreak ( core::pose::Pose pose,
core::Size const  pos 
)

evaluate linear chainbreak at a position

Remarks:
If necessary, will evaluate using a copy of the Pose with a cut fold tree. If cutpoint variants are present at chainbreak, will use existing variants and not modify them. If cutpoint variants are not found will add them and then remove them once calculation is finished.
If necessary, will evaluate using a copy of the Pose with a cut fold tree.

References add_cutpoint_variants(), core::scoring::methods::LinearChainbreakEnergy::finalize_total_energy(), core::pose::Pose::fold_tree(), fold_tree_from_pose(), linear_chainbreak(), core::pose::Pose::n_residue(), core::kinematics::FoldTree::new_jump(), and remove_cutpoint_variants().

void protocols::forge::methods::make_star_foldtree ( core::pose::Pose pose,
protocols::loops::Loops  loops 
)
core::kinematics::FoldTree protocols::forge::methods::merge ( core::kinematics::FoldTree const &  left_tree,
core::kinematics::FoldTree const &  right_tree 
)

merge two fold trees by jump between their roots

Parameters:
[in]left_tree
[in]right_tree
Returns:
Merged FoldTree with all vertices of right_tree placed to the right of vertices in left_tree. Jump labels in right_tree will be renumbered += left_tree.num_jump(). New tree is rooted in the same place as left_tree.

References core::kinematics::FoldTree::root().

Referenced by merge(), and protocols::forge::build::ConnectRight::modify_impl().

core::kinematics::FoldTree protocols::forge::methods::merge ( core::kinematics::FoldTree const &  left_tree,
core::Size const  left_position,
core::kinematics::FoldTree const &  right_tree,
core::Size const  right_position 
)

merge two fold trees connecting by jump via specified positions

Parameters:
[in]left_tree
[in]left_positionposition on left_tree to connect
[in]right_tree
[in]right_positionposition on right_tree to connect
Returns:
Merged FoldTree with all vertices of right_tree placed to the right of vertices in left_tree. Jump labels in right_tree will be renumbered += left_tree.num_jump(). New tree is rooted in the same place as left_tree.

References merge().

core::kinematics::FoldTree protocols::forge::methods::merge ( core::kinematics::FoldTree const &  left_tree,
core::Size const  left_position,
std::string const &  left_jump_atom,
core::kinematics::FoldTree const &  right_tree,
core::Size const  right_position,
std::string const &  right_jump_atom,
bool const  keep_stub_in_residue 
)

merge two fold trees connecting by jump via specified positions

Parameters:
[in]left_tree
[in]left_positionposition on left_tree to connect
[in]left_jump_atomUse this atom for the left side of the jump. Use empty string to indicate default setting.
[in]right_tree
[in]right_positionposition on right_tree to connect
[in]right_jump_atomUse this atom for the right set of the jump. Use empty string to indicate default setting.
[in]keep_stub_in_residueAttempt to keep generated stubs of the jump within their respective residues. default False
Returns:
Merged FoldTree with all vertices of right_tree placed to the right of vertices in left_tree. Jump labels in right_tree will be renumbered += left_tree.num_jump(). New tree is rooted in the same place as left_tree.

References make_table_of_pilot_apps::begin, core::kinematics::FoldTree::begin(), core::sequence::end, core::kinematics::FoldTree::end(), make_table_of_pilot_apps::f, facet_containing_position(), core::kinematics::FoldTree::nres(), core::kinematics::FoldTree::num_jump(), core::kinematics::FoldTree::root(), and vertex_exists().

bool protocols::forge::methods::order ( core::kinematics::Edge e)
core::Real protocols::forge::methods::overlap_chainbreak ( core::pose::Pose pose,
core::Size const  pos 
)

evaluate overlap chainbreak at a position

Remarks:
If necessary, will evaluate using a copy of the Pose with a cut fold tree. If cutpoint variants are present at chainbreak, will use existing variants and not modify them. If cutpoint variants are not found will add them and then remove them once calculation is finished.
If necessary, will evaluate using a copy of the Pose with a cut fold tree.

References add_cutpoint_variants(), core::scoring::methods::LinearChainbreakEnergy::finalize_total_energy(), core::pose::Pose::fold_tree(), fold_tree_from_pose(), core::pose::Pose::n_residue(), core::kinematics::FoldTree::new_jump(), overlap_chainbreak(), and remove_cutpoint_variants().

core::Real protocols::forge::methods::overlap_chainbreak ( core::pose::Pose const &  pose,
core::Size const  pos 
)

evaluate overlap chainbreak at a position

Remarks:
Copies the Pose, if necessary swaps the Pose with a cut fold tree, then evaluates the chainbreak.

References core::pose::Pose::fold_tree(), fold_tree_from_pose(), and core::kinematics::FoldTree::new_jump().

Referenced by overlap_chainbreak().

utility::vector1< bool > protocols::forge::methods::parse_resfile_string_with_no_lockdown ( core::pose::Pose const &  pose,
core::pack::task::PackerTask the_task,
std::string const &  resfile_string 
)
core::Real protocols::forge::methods::quadratic_chainbreak ( core::pose::Pose const &  pose,
core::Size const  pos 
)

evaluate quadratic chainbreak at a position

Remarks:
Copies the Pose, if necessary swaps the Pose with a cut fold tree, then evaluates the chainbreak.

References core::pose::Pose::fold_tree(), fold_tree_from_pose(), and core::kinematics::FoldTree::new_jump().

core::Real protocols::forge::methods::quadratic_chainbreak ( core::pose::Pose pose,
core::Size const  pos 
)

evaluate quadratic chainbreak at a position

Remarks:
If necessary, will evaluate using a copy of the Pose with a cut fold tree. If cutpoint variants are present at chainbreak, will use existing variants and not modify them. If cutpoint variants are not found will add them and then remove them once calculation is finished.
If necessary, will evaluate using a copy of the Pose with a cut fold tree.

References add_cutpoint_variants(), core::scoring::chainbreak, core::scoring::methods::ChainbreakEnergy::finalize_total_energy(), core::pose::Pose::fold_tree(), fold_tree_from_pose(), core::pose::Pose::n_residue(), core::kinematics::FoldTree::new_jump(), and remove_cutpoint_variants().

template<typename EdgeIterator >
utility::vector1< core::kinematics::Edge > protocols::forge::methods::regular_edges_within_interval ( core::Size const  left,
core::Size const  right,
EdgeIterator const  begin,
EdgeIterator const  end 
)

find regular (non-jump) edges contained within the interval [left, right]

References core::sequence::end, and order().

template<typename EdgeIterator >
EdgeIterator protocols::forge::methods::regular_facet_containing_position ( core::Size const  pos,
EdgeIterator const  begin,
EdgeIterator const  end 
)

find regular facet (non-jump edge sans face vertices) that contains given position

Parameters:
[in]posposition
[in]beginiterator pointing to the first edge to search
[in]enditerator pointing just past the last edge to search
Returns:
iterator pointing to the Edge defining the facet that contains the position; if vertex lies on the face of an edge or vertex not found, returns 'end'

References core::sequence::end.

Referenced by add_vertex().

core::pack::task::TaskFactoryOP protocols::forge::methods::remodel_generic_taskfactory ( )
bool protocols::forge::methods::remove_cutpoint ( core::Size const  v,
core::kinematics::FoldTree ft 
)

remove a cutpoint, merging the two sections that are adjacent to the cut

Returns:
true if cutpoint removed, false if not a cutpoint

References core::kinematics::FoldTree::delete_jump_and_intervening_cutpoint(), core::sequence::end, core::kinematics::FoldTree::is_cutpoint(), core::kinematics::FoldTree::nres(), order(), and union_interval().

Referenced by protocols::forge::build::Bridge::modify_impl().

bool protocols::forge::methods::remove_cutpoint_variants ( core::pose::Pose pose,
core::Size const  pos 
)

remove cutpoint variants at a specific position

Parameters:
[in,out]Poseto modify
[in]positionat which to remove cutpoint variants
Returns:
true if cutpoint variants removed, false if no cutpoint variants found or position not a topological cutpoint

References core::chemical::CUTPOINT_LOWER, core::chemical::CUTPOINT_UPPER, core::pose::Pose::fold_tree(), core::conformation::Residue::has_variant_type(), core::pose::Pose::n_residue(), core::pose::remove_variant_type_from_pose_residue(), and core::pose::Pose::residue().

Referenced by linear_chainbreak(), overlap_chainbreak(), and quadratic_chainbreak().

void protocols::forge::methods::remove_cutpoints ( utility::vector1< core::Size > const &  cutpoints,
core::kinematics::FoldTree ft 
)

seal a fold tree by removing all specified cutpoints

Parameters:
[in]cutpointsCutpoints to remove.
[in,out]ftThe input tree.
Returns:
A new tree with cutpoints removed and all other topology kept constant.

References core::kinematics::FoldTree::delete_jump_and_intervening_cutpoint(), core::sequence::end, core::kinematics::FoldTree::nres(), order(), and union_interval().

core::kinematics::FoldTree protocols::forge::methods::replace ( core::kinematics::FoldTree const &  original_tree,
int const  replace_begin,
int const  replace_end,
core::kinematics::MoveMap const &  movemap,
core::kinematics::FoldTree const &  replacement_tree 
)

replace a section of one fold tree with another fold tree, connecting by jump between their roots

Parameters:
[in]original_tree
[in]replace_beginresidue starting the section of original_tree to replace
[in]replace_endresidue ending the section of original_tree to replace
[in]movemapMoveMap whose fixed backbone positions dictates where new jumps may be placed.
[in]replacement_tree
Returns:
FoldTree with section replaced.
Remarks:
The procedure will attempt to honor the MoveMap as much as it can. The caveat is that sequences of calls to some FoldTree routines may shift the jumps internally in a way that is not easily predictable. If the procedure cannot find an allowed residue for a jump, it will make a jump to the median residue in the disconnected fold tree interval.

References core::kinematics::FoldTree::begin(), make_table_of_pilot_apps::begin, core::kinematics::FoldTree::delete_seqpos(), core::graph::DisjointSets::ds_find(), core::graph::DisjointSets::ds_union(), core::kinematics::FoldTree::end(), core::sequence::end, facet_containing_position(), core::kinematics::MoveMap::get_bb(), core::graph::DisjointSets::n_disjoint_sets(), core::kinematics::FoldTree::nres(), order(), RG(), core::kinematics::FoldTree::root(), core::graph::DisjointSets::sets(), TR(), and union_interval().

Referenced by core::io::silent::SilentStruct::add_energy(), core::io::silent::SilentStruct::add_string_value(), protocols::medal::MedalExchangeMover::apply(), core::conformation::symmetry::comma_strings_to_map(), core::conformation::symmetry::comma_strings_to_vector(), core::conformation::symmetry::comma_strings_to_vector_map(), core::io::silent::SilentStruct::copy_scores(), protocols::frag_picker::FragmentPicker::fragment_contacts(), protocols::forge::build::SegmentSwap::modify_impl(), protocols::frag_picker::FragmentPicker::nonlocal_pairs(), and core::conformation::symmetry::SymDof::read().

void protocols::forge::methods::restore_residues ( core::pose::Pose archive_pose,
core::pose::Pose pose 
)

restore residues (i.e. sidechains)

Parameters:
[in]archive_posethe original Pose to take residues from
[out]posethe altered Pose that needs residue restoration
Remarks:
length between two poses must be equal

References core::pose::Pose::n_residue(), and restore_residues().

void protocols::forge::methods::restore_residues ( std::map< core::Size, core::Size > const &  old2new,
core::pose::Pose archive_pose,
core::pose::Pose pose 
)

restore residues (i.e. sidechains)

Parameters:
[in]old2newmap indicating residues to be transferred and the mapping from archive_pose position -> pose position
[in]archive_posethe original Pose to take residues from
[out]posethe altered Pose that needs residue restoration

References core::scoring::Energies::clear(), core::pose::Pose::conformation(), core::scoring::ScoreFunctionFactory::create_score_function(), core::conformation::Conformation::detect_disulfides(), core::pose::Pose::energies(), core::pose::Pose::is_fullatom(), core::pack::pack_rotamers(), core::pose::Pose::replace_residue(), core::pose::Pose::residue(), core::scoring::SCORE12_PATCH, and core::scoring::STANDARD_WTS.

Referenced by protocols::forge::components::VarLengthBuild::apply(), and restore_residues().

static numeric::random::RandomGenerator protocols::forge::methods::RG ( 2211990  ) [static]
static numeric::random::RandomGenerator protocols::forge::methods::RG ( 2557316  ) [static]
void protocols::forge::methods::set_single_loop_fold_tree ( core::pose::Pose pose,
protocols::loops::Loop const &  loop 
)
core::kinematics::FoldTree protocols::forge::methods::shift_jumps ( core::kinematics::FoldTree const &  ft,
core::kinematics::MoveMap const &  mm 
)

attempt to shift jumps in a fold tree based on fixed positions in a MoveMap

Parameters:
[in]ftFoldTree to alter
[in]movemapMoveMap to try and honor
Returns:
FoldTree with jumps shifted, if possible
Remarks:
Procedure will shift a jump position on a continuous segment to a randomly selected fixed position on that segment specified by the MoveMap. No changes will be made to a jump point if it is contained within a segment lacking valid fixed positions. This procedure has the side effect of collapsing all jump points to a single point within segments that have fixed positions.

References add_vertex(), core::graph::EdgeList::begin(), core::kinematics::FoldTree::begin(), core::graph::EdgeList::end(), core::kinematics::FoldTree::end(), core::kinematics::MoveMap::get_bb(), core::kinematics::FoldTree::nres(), order(), core::graph::EdgeList::push_back(), RG(), core::kinematics::FoldTree::root(), and union_interval().

core::fragment::ConstantLengthFragSetOP protocols::forge::methods::smallmer_from_largemer ( core::fragment::FrameIterator  begin,
core::fragment::FrameIterator  end,
core::Size const  smallmer_size,
bool const  all_possible_smallmers 
)

create small-mers from large-mers

Parameters:
[in]all_possible_smallmersDefault false. If true, grab all possible smallmers using every possible starting position in a largemer (you could end up with a *lot* of fragments per position). If false, grab smallmers using only the first position of a largemer as the starting position.

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

Referenced by protocols::forge::components::VarLengthBuild::pick_all_fragments().

static basic::Tracer protocols::forge::methods::TR ( "protocols.forge.methods.util"  ) [static]
static basic::Tracer protocols::forge::methods::TR ( "protocols.forge.methods.fold_tree_functions"  ) [static]
static basic::Tracer protocols::forge::methods::TR ( "protocols.forge.methods.pose_mod"  ) [static]
void protocols::forge::methods::trans_omega ( core::Size const  left,
core::Size const  right,
core::pose::Pose pose 
)
void protocols::forge::methods::union_interval ( core::Size const  root,
core::Size const  left,
core::Size const  right,
core::graph::DisjointSets uf 
)

perform union( root, i ) for all 'i' within the closed interval [left, right]

Parameters:
[in]rootposition to union with; can be any number, does not have to be a true root of a set
[in]leftstart of the interval
[in]rightend of the interval
[in,out]uf

References core::graph::DisjointSets::ds_union(), and core::graph::DisjointSets::n_nodes().

Referenced by find_connecting_jump(), remove_cutpoint(), remove_cutpoints(), replace(), and shift_jumps().

bool protocols::forge::methods::vertex_exists ( core::Size const  v,
core::kinematics::FoldTree const &  ft 
)

query if vertex already exists in fold tree

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

Referenced by merge().

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines