Module _core_kinematics_

add_atom( (int)atomno, (int)seqpos, (vec1_vec1_Size)links, (object)atom_ptr, (bool)add_jump_atom) -> object :
    creat an atom and add it to the residue atom-tree based on information stored in links.
    

    C++ signature :
        boost::shared_ptr<core::kinematics::tree::Atom> add_atom(int,int,utility::vector1<utility::vector1<unsigned long, std::allocator<unsigned long> >, std::allocator<utility::vector1<unsigned long, std::allocator<unsigned long> > > >,utility::vector1<boost::shared_ptr<core::kinematics::tree::Atom>, std::allocator<boost::shared_ptr<core::kinematics::tree::Atom> > > {lvalue},bool)

distance( (Jump)a_in, (Jump)b_in) -> float :
    RT root squared deviation
    

    C++ signature :
        double distance(core::kinematics::Jump,core::kinematics::Jump)

distance( (RT)a, (RT)b) -> float :
    ////////////////////////////////////////////////////////////////////////////
     root squared devitation of two RTs
    

    C++ signature :
        double distance(core::kinematics::RT,core::kinematics::RT)

distance( (Stub)a, (Stub)b) -> float :
    root squared deviation between two stubs
    

    C++ signature :
        double distance(core::kinematics::Stub,core::kinematics::Stub)

jump_distance( (Jump)a_in, (Jump)b_in, (float)dist, (float)theta) -> None :
    compare the difference of two jumps in term of the translation (dist) and rotational angle(theta)
    

    C++ signature :
        void jump_distance(core::kinematics::Jump,core::kinematics::Jump,double {lvalue},double {lvalue})

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

    C++ signature :
        core::kinematics::FoldTree linearize_fold_tree(core::kinematics::FoldTree)

pick_loopy_cutpoint( (int)n_res, (object)cut_bias_sum) -> int :
    core/kinematics/util.hh:54

    C++ signature :
        int pick_loopy_cutpoint(unsigned long,ObjexxFCL::FArray1D<float>)

remodel_fold_tree_to_account_for_insertion( (FoldTree)input_tree, (int)insert_after, (int)insert_size) -> FoldTree :
    remodel a fold tree to account for a large insertion by adding the size of the insert to upstream positions
    Steven Lewis smlewi@gmail.com as a favor for Jared
    

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

setup_backrub_atom_tree( (vector1_AtomID)mainchain, (AtomID)downstream_id, (object)old_atom_pointer, (vector1_pair_Size_Size)edges, (int)first_new_pseudo_residue) -> object :
    core/kinematics/util.hh:63

    C++ signature :
        boost::shared_ptr<core::kinematics::tree::Atom> setup_backrub_atom_tree(utility::vector1<core::id::AtomID, std::allocator<core::id::AtomID> >,core::id::AtomID,core::id::AtomID_Map<boost::shared_ptr<core::kinematics::tree::Atom> >,utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > >,unsigned long)

simple_visualize_fold_tree( (FoldTree)fold_tree, (OStream)out) -> None :
    prints something like this ***1***C***1*********2***C********3****C****2********3*****
    

    C++ signature :
        void simple_visualize_fold_tree(core::kinematics::FoldTree,std::ostream {lvalue})

simple_visualize_fold_tree_and_movemap( (FoldTree)fold_tree, (MoveMap)mm, (OStream)out) -> None :
    prints something like this ***1***C***1*********2***C********3****C****2********3*****
                                      **********xxxxxxxxxxxxx************************************
    

    C++ signature :
        void simple_visualize_fold_tree_and_movemap(core::kinematics::FoldTree,core::kinematics::MoveMap,std::ostream {lvalue})

simple_visualize_fold_tree_and_movemap_bb_chi( (FoldTree)fold_tree, (MoveMap)mm, (OStream)out) -> None :
    prints something like this ***1***C***1*********2***C********3****C****2********3*****
                                      **********xxxxxxxxxxxxx************************************
    

    C++ signature :
        void simple_visualize_fold_tree_and_movemap_bb_chi(core::kinematics::FoldTree,core::kinematics::MoveMap,std::ostream {lvalue})

visualize_fold_tree( (FoldTree)fold_tree, (map_Size_string)node_labels_partial, (object)mark_jump_to_res, (map_Size_Size)jump_follows) -> str :
    core/kinematics/util.hh:109

    C++ signature :
        std::string visualize_fold_tree(core::kinematics::FoldTree,std::map<unsigned long, std::string, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::string> > >,std::map<unsigned long, char, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, char> > >,std::map<unsigned long, unsigned long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, unsigned long> > >)

visualize_fold_tree( (FoldTree)fold_tree, (object)mark_jump_to_res) -> str :
    core/kinematics/util.hh:101

    C++ signature :
        std::string visualize_fold_tree(core::kinematics::FoldTree,std::map<unsigned long, char, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, char> > >)

visualize_fold_tree( (FoldTree)fold_tree, (map_Size_string)node_labels_partial) -> str :
    core/kinematics/util.hh:95

    C++ signature :
        std::string visualize_fold_tree(core::kinematics::FoldTree,std::map<unsigned long, std::string, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::string> > >)

visualize_fold_tree( (FoldTree)fold_tree) -> str :
    sheffler
    

    C++ signature :
        std::string visualize_fold_tree(core::kinematics::FoldTree)