Module _protocols_forge_methods_

add_cutpoint_variants( (Pose)pose, (int)pos) -> bool :
    add cutpoint variants at a specific position
    [in,out] Pose to modify
    [in] position at which to add cutpoint variants
    true if cutpoint variants added, false if position not a topological cutpoint
    

    C++ signature :
        bool add_cutpoint_variants(core::pose::Pose {lvalue},unsigned long)

apply_transformation( (Pose)mod_pose, (object)residue_list, (xyzMatrix_Real)R, (xyzVector_Real)preT, (xyzVector_Real)postT) -> None :
    protocols/forge/methods/util.hh:270

    C++ signature :
        void apply_transformation(core::pose::Pose {lvalue},std::list<unsigned long, std::allocator<unsigned long> >,numeric::xyzMatrix<double>,numeric::xyzVector<double>,numeric::xyzVector<double>)

calc_rsd_sasa( (Pose)pose) -> vector1_Real :
    protocols/forge/methods/util.hh:263

    C++ signature :
        utility::vector1<double, std::allocator<double> > calc_rsd_sasa(core::pose::Pose)

closest_larger_peptide_vertex( (int)v, (FoldTree)ft [, (int)k=1]) -> int :
    find the k'th closest larger peptide vertex of given vertex in fold tree
    [in] v the given vertex
    [in] ft fold tree to search
    [in] k find the k'th closest, must be > 0
    0 if no such vertex
    

    C++ signature :
        unsigned long closest_larger_peptide_vertex(unsigned long,core::kinematics::FoldTree [,unsigned long=1])

closest_smaller_peptide_vertex( (int)v, (FoldTree)ft [, (int)k=1]) -> int :
    find the k'th closest smaller peptide vertex of given vertex in fold tree
    [in] v the given vertex
    [in] ft fold tree to search
    [in] k find the k'th closest, must be > 0
    0 if no such vertex
    

    C++ signature :
        unsigned long closest_smaller_peptide_vertex(unsigned long,core::kinematics::FoldTree [,unsigned long=1])

count_cutpoints( (Pose)pose, (int)left, (int)right) -> int :
    moving left to right, count the number of true cutpoints within the
     specified extent
    

    C++ signature :
        unsigned long count_cutpoints(core::pose::Pose,unsigned long,unsigned long)

cyclize_pose( (Pose)pose) -> None :
    protocols/forge/methods/util.hh:274

    C++ signature :
        void cyclize_pose(core::pose::Pose {lvalue})

fill_non_loop_cst_set( (Pose)pose, (Loops)loops) -> None :
    protocols/forge/methods/util.hh:260

    C++ signature :
        void fill_non_loop_cst_set(core::pose::Pose {lvalue},protocols::loops::Loops)

find_connecting_jump( (int)u, (int)v, (FoldTree)ft) -> int :
    find the jump connecting two continuous segments of a fold tree
    [in] u Any vertex on the first segment.
    [in] v Any vertex on the second segment.
    [in] ft The fold tree to query.
    the jump number connecting the two segments, 0 if no such jump
    

    C++ signature :
        unsigned long find_connecting_jump(unsigned long,unsigned long,core::kinematics::FoldTree)

find_cutpoint( (Pose)pose, (int)left, (int)right) -> int :
    moving left to right, find the first true cutpoint within the specified
     extent
    the cutpoint position, otherwise 0 if not found
    

    C++ signature :
        unsigned long find_cutpoint(core::pose::Pose,unsigned long,unsigned long)

fold_tree_from_loops( (Pose)pose, (Loops)loops) -> FoldTree :
    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.
    

    C++ signature :
        core::kinematics::FoldTree fold_tree_from_loops(core::pose::Pose,protocols::loops::Loops)

fold_tree_from_pose( (Pose)pose, (int)ft_root, (MoveMap)mm) -> FoldTree :
    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.
    [in] pose Pose.
    [in] ft_root Root of the new fold tree.
    [in] mm MoveMap used to select jump positions.
    fold tree wrt chain endings and residue types
    

    C++ signature :
        core::kinematics::FoldTree fold_tree_from_pose(core::pose::Pose,unsigned long,core::kinematics::MoveMap)

grow_left_r( (Pose)pose, (int)anchor, (object)begin, (object)end [, (bool)correct_terminus=True [, (bool)use_existing_crd=False]]) -> int :
    grow a series of residues to the left of a position
    [in,out] pose Pose the pose to modify
    [in] anchor the anchor position
    [in] begin iterator that points to the first ResidueOP
    [in] end iterator that points just beyond the last ResidueOP
    [in] correct_terminus re-add lower terminus if found, default true
    [in] use_existing_crd No idealization: place residues with existing
     coordinates, default false.
    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.
    

    C++ signature :
        unsigned long grow_left_r(core::pose::Pose {lvalue},unsigned long,__gnu_cxx::__normal_iterator<boost::shared_ptr<core::conformation::Residue>*, std::vector<boost::shared_ptr<core::conformation::Residue>, std::allocator<boost::shared_ptr<core::conformation::Residue> > > >,__gnu_cxx::__normal_iterator<boost::shared_ptr<core::conformation::Residue>*, std::vector<boost::shared_ptr<core::conformation::Residue>, std::allocator<boost::shared_ptr<core::conformation::Residue> > > > [,bool=True [,bool=False]])

grow_right_r( (Pose)pose, (int)anchor, (object)begin, (object)end [, (bool)correct_terminus=True [, (bool)use_existing_crd=False]]) -> int :
    grow a series of residues to the right of a position
    [in,out] pose Pose the pose to modify
    [in] anchor the anchor position, can be 0 if operating on empty
     Pose
    [in] begin iterator that points to the first ResidueOP
    [in] end iterator that points just beyond the last ResidueOP
    [in] correct_terminus re-add upper terminus if found, default true
    [in] use_existing_crd No idealization: place residues with existing
     coordinates, default false.
    the right endpoint of the new growth or zero if nothing to do
    

    C++ signature :
        unsigned long grow_right_r(core::pose::Pose {lvalue},unsigned long,__gnu_cxx::__normal_iterator<boost::shared_ptr<core::conformation::Residue>*, std::vector<boost::shared_ptr<core::conformation::Residue>, std::allocator<boost::shared_ptr<core::conformation::Residue> > > >,__gnu_cxx::__normal_iterator<boost::shared_ptr<core::conformation::Residue>*, std::vector<boost::shared_ptr<core::conformation::Residue>, std::allocator<boost::shared_ptr<core::conformation::Residue> > > > [,bool=True [,bool=False]])

interval_to_loop( (object)interval) -> Loop :
    create Loop object w/ random cutpoint from an Interval
    

    C++ signature :
        protocols::loops::Loop interval_to_loop(protocols::forge::build::Interval)

jumps_and_cuts_from_pose( (Pose)pose, (vector1_pair_Size_Size)jumps, (vector1_Size)cuts) -> None :
    protocols/forge/methods/fold_tree_functions.hh:433

    C++ signature :
        void jumps_and_cuts_from_pose(core::pose::Pose {lvalue},utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > > {lvalue},utility::vector1<unsigned long, std::allocator<unsigned long> > {lvalue})

jumps_connected_to_position( (int)pos, (FoldTree)ft) -> object :
    find all jump edges whose start or stop lands on the given position
    [in] pos The position.
    [in] ft The fold tree.
    a list of jump edges
    @remarks jump edges start/stop will be ordered such that 'pos' will always
     be at 'start'.
    

    C++ signature :
        utility::vector1<core::kinematics::Edge, std::allocator<core::kinematics::Edge> > jumps_connected_to_position(unsigned long,core::kinematics::FoldTree)

linear_chainbreak( (Pose)pose, (int)pos) -> float :
    evaluate linear chainbreak at a position
    @remarks If necessary, will evaluate using a copy of the Pose with a cut
     fold tree.
    

    C++ signature :
        double linear_chainbreak(core::pose::Pose {lvalue},unsigned long)

linear_chainbreak( (Pose)pose, (int)pos) -> float :
    evaluate linear chainbreak at a position
    @remarks Copies the Pose, if necessary swaps the Pose with a cut fold tree,
     then evaluates the chainbreak.
    

    C++ signature :
        double linear_chainbreak(core::pose::Pose,unsigned long)

make_star_foldtree( (Pose)pose, (Loops)loops) -> None :
    protocols/forge/methods/fold_tree_functions.hh:431

    C++ signature :
        void make_star_foldtree(core::pose::Pose {lvalue},protocols::loops::Loops)

merge( (FoldTree)left_tree, (int)left_position, (str)left_jump_atom, (FoldTree)right_tree, (int)right_position, (str)right_jump_atom [, (bool)keep_stub_in_residue=False]) -> FoldTree :
    merge two fold trees connecting by jump via specified positions
    [in] left_tree
    [in] left_position position on left_tree to connect
    [in] left_jump_atom Use this atom for the left side of the jump.
     Use empty string to indicate default setting.
    [in] right_tree
    [in] right_position position on right_tree to connect
    [in] right_jump_atom Use this atom for the right set of the jump.
     Use empty string to indicate default setting.
    [in] keep_stub_in_residue Attempt to keep generated stubs of the
     jump within their respective residues.  default False
    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.
    

    C++ signature :
        core::kinematics::FoldTree merge(core::kinematics::FoldTree,unsigned long,std::string,core::kinematics::FoldTree,unsigned long,std::string [,bool=False])

merge( (FoldTree)left_tree, (int)left_position, (FoldTree)right_tree, (int)right_position) -> FoldTree :
    merge two fold trees connecting by jump via specified positions
    [in] left_tree
    [in] left_position position on left_tree to connect
    [in] right_tree
    [in] right_position position on right_tree to connect
    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.
    

    C++ signature :
        core::kinematics::FoldTree merge(core::kinematics::FoldTree,unsigned long,core::kinematics::FoldTree,unsigned long)

merge( (FoldTree)left_tree, (FoldTree)right_tree) -> FoldTree :
    merge two fold trees by jump between their roots
    [in] left_tree
    [in] right_tree
    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.
    

    C++ signature :
        core::kinematics::FoldTree merge(core::kinematics::FoldTree,core::kinematics::FoldTree)

order( (Edge)e) -> bool :
    enforce Edge has start <= stop (swap if necessary)
    true if start and stop were swapped
    

    C++ signature :
        bool order(core::kinematics::Edge {lvalue})

overlap_chainbreak( (Pose)pose, (int)pos) -> float :
    evaluate overlap chainbreak at a position
    @remarks If necessary, will evaluate using a copy of the Pose with a cut
     fold tree.
    

    C++ signature :
        double overlap_chainbreak(core::pose::Pose {lvalue},unsigned long)

overlap_chainbreak( (Pose)pose, (int)pos) -> float :
    evaluate overlap chainbreak at a position
    @remarks Copies the Pose, if necessary swaps the Pose with a cut fold tree,
     then evaluates the chainbreak.
    

    C++ signature :
        double overlap_chainbreak(core::pose::Pose,unsigned long)

parse_resfile_string_with_no_lockdown( (Pose)pose, (PackerTask)the_task, (str)resfile_string) -> vector1_bool :
    protocols/forge/methods/util.hh:252

    C++ signature :
        utility::vector1<bool, std::allocator<bool> > parse_resfile_string_with_no_lockdown(core::pose::Pose,core::pack::task::PackerTask {lvalue},std::string)

quadratic_chainbreak( (Pose)pose, (int)pos) -> float :
    evaluate quadratic chainbreak at a position
    @remarks If necessary, will evaluate using a copy of the Pose with a cut
     fold tree.
    

    C++ signature :
        double quadratic_chainbreak(core::pose::Pose {lvalue},unsigned long)

quadratic_chainbreak( (Pose)pose, (int)pos) -> float :
    evaluate quadratic chainbreak at a position
    @remarks Copies the Pose, if necessary swaps the Pose with a cut fold tree,
     then evaluates the chainbreak.
    

    C++ signature :
        double quadratic_chainbreak(core::pose::Pose,unsigned long)

    protocols/forge/methods/util.hh:255

    C++ signature :
        boost::shared_ptr<core::pack::task::TaskFactory> remodel_generic_taskfactory()

Returns: TaskFactory :

remove_cutpoint( (int)v, (FoldTree)ft) -> bool :
    remove a cutpoint, merging the two sections that are adjacent to the cut
    true if cutpoint removed, false if not a cutpoint
    

    C++ signature :
        bool remove_cutpoint(unsigned long,core::kinematics::FoldTree {lvalue})

remove_cutpoint_variants( (Pose)pose, (int)pos) -> bool :
    remove cutpoint variants at a specific position
    [in,out] Pose to modify
    [in] position at which to remove cutpoint variants
    true if cutpoint variants removed, false if no cutpoint variants found
     or position not a topological cutpoint
    

    C++ signature :
        bool remove_cutpoint_variants(core::pose::Pose {lvalue},unsigned long)

remove_cutpoints( (vector1_Size)cutpoints, (FoldTree)ft) -> None :
    seal a fold tree by removing all specified cutpoints
    [in] cutpoints Cutpoints to remove.
    [in,out] ft The input tree.
    A new tree with cutpoints removed and all other topology kept
     constant.
    

    C++ signature :
        void remove_cutpoints(utility::vector1<unsigned long, std::allocator<unsigned long> >,core::kinematics::FoldTree {lvalue})

replace( (FoldTree)original_tree, (int)replace_begin, (int)replace_end, (MoveMap)movemap, (FoldTree)replacement_tree) -> FoldTree :
    replace a section of one fold tree with another fold tree, connecting by
     jump between their roots
    [in] original_tree
    [in] replace_begin residue starting the section of original_tree to replace
    [in] replace_end residue ending the section of original_tree to replace
    [in] movemap MoveMap whose fixed backbone positions dictates where new jumps
     may be placed.
    [in] replacement_tree
    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.
    

    C++ signature :
        core::kinematics::FoldTree replace(core::kinematics::FoldTree,int,int,core::kinematics::MoveMap,core::kinematics::FoldTree)

restore_residues( (Pose)archive_pose, (Pose)pose) -> None :
    restore residues (i.e. sidechains)
    [in] archive_pose the original Pose to take residues from
    [out] pose the altered Pose that needs residue restoration
    @remarks length between two poses must be equal
    

    C++ signature :
        void restore_residues(core::pose::Pose {lvalue},core::pose::Pose {lvalue})

restore_residues( (map_Size_Size)old2new, (Pose)archive_pose, (Pose)pose) -> None :
    restore residues (i.e. sidechains)
    [in] old2new map indicating residues to be transferred and
     the mapping from archive_pose position -> pose position
    [in] archive_pose the original Pose to take residues from
    [out] pose the altered Pose that needs residue restoration
    

    C++ signature :
        void restore_residues(std::map<unsigned long, unsigned long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, unsigned long> > >,core::pose::Pose {lvalue},core::pose::Pose {lvalue})

set_single_loop_fold_tree( (Pose)pose, (Loop)loop) -> None :
    set a single loop fold tree
    @remarks This is a generic replacement function for the one in protocols::loops
     and will be moved there in the near future.
    

    C++ signature :
        void set_single_loop_fold_tree(core::pose::Pose {lvalue},protocols::loops::Loop)

shift_jumps( (FoldTree)ft, (MoveMap)mm) -> FoldTree :
    attempt to shift jumps in a fold tree based on fixed positions in a MoveMap
    [in] ft FoldTree to alter
    [in] movemap MoveMap to try and honor
    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.
    

    C++ signature :
        core::kinematics::FoldTree shift_jumps(core::kinematics::FoldTree,core::kinematics::MoveMap)

smallmer_from_largemer( (ConstFrameIterator)begin, (ConstFrameIterator)end [, (int)smallmer_size=1 [, (bool)all_possible_smallmers=False]]) -> ConstantLengthFragSet :
    create small-mers from large-mers
    [in] all_possible_smallmers Default 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.
    

    C++ signature :
        boost::shared_ptr<core::fragment::ConstantLengthFragSet> smallmer_from_largemer(core::fragment::ConstFrameIterator,core::fragment::ConstFrameIterator [,unsigned long=1 [,bool=False]])

trans_omega( (int)left, (int)right, (Pose)pose) -> None :
    set omega to 180 for a range of residues [left, right]
    

    C++ signature :
        void trans_omega(unsigned long,unsigned long,core::pose::Pose {lvalue})

union_interval( (int)root, (int)left, (int)right, (DisjointSets)uf) -> None :
    perform union( root, i ) for all 'i' within the closed interval
     [left, right]
    [in] root position to union with; can be any number, does not have
     to be a true root of a set
    [in] left start of the interval
    [in] right end of the interval
    [in,out] uf
    

    C++ signature :
        void union_interval(unsigned long,unsigned long,unsigned long,core::graph::DisjointSets {lvalue})

vertex_exists( (int)v, (FoldTree)ft) -> bool :
    query if vertex already exists in fold tree
    

    C++ signature :
        bool vertex_exists(unsigned long,core::kinematics::FoldTree)