init( (object)arg1, (object)new_atom_pointer [, (bool)from_xyz=True]) -> None : ///////////////////////// construction: from a tree of atoms;

C++ signature :
    void __init__(_object*,core::id::AtomID_Map<boost::shared_ptr<core::kinematics::tree::Atom> > [,bool=True])

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (AtomTree)src) -> None : copy constructor

C++ signature :
    void __init__(_object*,core::kinematics::AtomTree)

assign( (AtomTree)arg1, (AtomTree)src) -> AtomTree : Copy assignment, makes complete copy of another AtomTree

C++ signature : core::kinematics::AtomTree {lvalue} assign(core::kinematics::AtomTree {lvalue},core::kinematics::AtomTree)

atom( (AtomTree)arg1, (AtomID)id) -> object : core/kinematics/AtomTree.hh:344

C++ signature : core::kinematics::tree::Atom atom(core::kinematics::AtomTree {lvalue},core::id::AtomID)

atom_dont_do_update( (AtomTree)arg1, (AtomID)id) -> object : core/kinematics/AtomTree.hh:347

C++ signature : core::kinematics::tree::Atom atom_dont_do_update(core::kinematics::AtomTree {lvalue},core::id::AtomID)

batch_set_xyz( (AtomTree)arg1, (vector1_AtomID)id, (vector1_xyzVector_Real)xyz) -> None : simultaniously set several atom xyz positions

C++ signature : void batch_set_xyz(core::kinematics::AtomTree {lvalue},utility::vector1 >,utility::vector1, std::allocator > >)

bond_angle( (AtomTree)arg1, (AtomID)atom1, (AtomID)atom2, (AtomID)atom3) -> float : core/kinematics/AtomTree.hh:411

C++ signature : double bond_angle(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID,core::id::AtomID)

bond_angle_dof_id( (AtomTree)arg1, (AtomID)atom1_in_id, (AtomID)atom2_in_id, (AtomID)atom3_in_id, (float)offset) -> DOF_ID : get the DOF_ID of a bond angle given those 3 atoms which define this torsion

C++ signature : core::id::DOF_ID bond_angle_dof_id(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID,core::id::AtomID,double {lvalue})

bond_length( (AtomTree)arg1, (AtomID)atom1, (AtomID)atom2) -> float : core/kinematics/AtomTree.hh:417

C++ signature : double bond_length(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID)

bond_length_dof_id( (AtomTree)arg1, (AtomID)atom1_in_id, (AtomID)atom2_in_id) -> DOF_ID : get the DOF_ID of a bond length given those 2 atoms which define this torsion

C++ signature : core::id::DOF_ID bond_length_dof_id(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID)

clear( (AtomTree)arg1) -> None : clear the content of an AtomTree object, delete root atom and all pointers

C++ signature : void clear(core::kinematics::AtomTree {lvalue})

copy_coords( (AtomTree)arg1, (AtomTree)src) -> None : copy the internal and xyz coords from src tree, which should have the same topology as me

C++ signature : void copy_coords(core::kinematics::AtomTree {lvalue},core::kinematics::AtomTree)

delete_seqpos( (AtomTree)arg1, (int)seqpos) -> None : Deletes atoms for seqpos. Does not renumber other atoms -- need to call update_sequence_numbering for that designed for the simple case of 1 incoming connecting and 0 or 1 outgoing connection, where the desired behavior is to rewire the outgoing connection in place of seqpos' tree

C++ signature : void delete_seqpos(core::kinematics::AtomTree {lvalue},unsigned long)

dof( (AtomTree)arg1, (DOF_ID)id) -> float : get value of DOF( PHI, THETA, D, RB1, ....) given its DOF_ID

C++ signature : double dof(core::kinematics::AtomTree {lvalue},core::id::DOF_ID)

empty( (AtomTree)arg1) -> bool : is there any atom in the tree yet?

C++ signature : bool empty(core::kinematics::AtomTree {lvalue})

get_jump_atom_id( (AtomTree)arg1, (StubID)stub_id1, (StubID)stub_id2, (int)direction) -> AtomID : find the atom giving rise to the jump connecting two stubs. direction is set to 1 or -1 depending on the direction of the jump

C++ signature : core::id::AtomID get_jump_atom_id(core::kinematics::AtomTree {lvalue},core::id::StubID,core::id::StubID,int {lvalue})

get_stub_transform( (AtomTree)arg1, (StubID)stub_id1, (StubID)stub_id2) -> RT : get the transform between two stubs

C++ signature : core::kinematics::RT get_stub_transform(core::kinematics::AtomTree {lvalue},core::id::StubID,core::id::StubID)

has( (AtomTree)arg1, (AtomID)id) -> bool : the atom with this AtomID in the current AtomID_Map? true only if AtomID is in the range of the map and its Atom pointer has value

C++ signature : bool has(core::kinematics::AtomTree {lvalue},core::id::AtomID)

insert_fragment( (AtomTree)arg1, (StubID)instub_id, (object)outstub_transforms, (object)frag_xyz, (vector1_AtomID)moving_atoms) -> None : core/kinematics/AtomTree.hh:294

C++ signature : void insert_fragment(core::kinematics::AtomTree {lvalue},core::id::StubID,std::map, std::allocator > >,std::map, std::less, std::allocator > > >,utility::vector1 > {lvalue})

jump( (AtomTree)arg1, (AtomID)id) -> Jump : core/kinematics/AtomTree.hh:351

C++ signature : core::kinematics::Jump jump(core::kinematics::AtomTree {lvalue},core::id::AtomID)

note_coordinate_change_registered( (AtomTree)arg1) -> None : The AtomTree provides a list of residues who's xyz coordinates have changed to the Conformation object. When the Conformation has finished reading off residues that have changed from the AtomTree, and has copied the coordinates of those residues into its conformation::Residue objects, it informs the AtomTree to reset this list by a call to mark_changed_residues_registered

C++ signature : void note_coordinate_change_registered(core::kinematics::AtomTree {lvalue})

promote_sameresidue_nonjump_child( (AtomTree)arg1, (AtomID)parent_atom_id) -> None : Useful for guaranteeing that a stub remains within a single residue

C++ signature : void promote_sameresidue_nonjump_child(core::kinematics::AtomTree {lvalue},core::id::AtomID)

replace_residue_subtree( (AtomTree)arg1, (BondID)incoming, (object)outgoing, (object)new_atoms) -> None : core/kinematics/AtomTree.hh:167

C++ signature : void replace_residue_subtree(core::kinematics::AtomTree {lvalue},core::id::BondID,utility::vector1 >,utility::vector1, std::allocator > >)

replace_tree( (AtomTree)arg1, (object)new_atom_pointer [, (bool)from_xyz=True]) -> None : replaces the entire tree

C++ signature : void replace_tree(core::kinematics::AtomTree {lvalue},core::id::AtomID_Map > [,bool=True])

residue_xyz_change_list_begin( (AtomTree)arg1) -> object : The AtomTree provides to the Conformation object a list of residues whose xyz coordinates have changed. When the Conformation has finished reading off residues that have changed from the AtomTree, and has copied the coordinates of those residues into its conformation::Residue objects, it informs the AtomTree to reset this list by a call to mark_changed_residues_registered

C++ signature : gnu_cxx::normal_iterator > > residue_xyz_change_list_begin(core::kinematics::AtomTree {lvalue})

residue_xyz_change_list_end( (AtomTree)arg1) -> object : core/kinematics/AtomTree.hh:306

C++ signature : gnu_cxx::normal_iterator > > residue_xyz_change_list_end(core::kinematics::AtomTree {lvalue})

root( (AtomTree)arg1) -> object : const-access to the root of the tree

C++ signature : boost::shared_ptr root(core::kinematics::AtomTree {lvalue})

set_bond_angle( (AtomTree)arg1, (AtomID)atom1, (AtomID)atom2, (AtomID)atom3, (float)setting) -> DOF_ID : core/kinematics/AtomTree.hh:262

C++ signature : core::id::DOF_ID set_bond_angle(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID,core::id::AtomID,double)

set_bond_length( (AtomTree)arg1, (AtomID)atom1, (AtomID)atom2, (float)setting) -> DOF_ID : core/kinematics/AtomTree.hh:269

C++ signature : core::id::DOF_ID set_bond_length(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID,double)

set_dof( (AtomTree)arg1, (DOF_ID)id, (float)setting) -> None : set a specific DOF in the tree

C++ signature : void set_dof(core::kinematics::AtomTree {lvalue},core::id::DOF_ID,double)

set_jump( (AtomTree)arg1, (AtomID)id, (Jump)jump) -> None : set a specific jump transform

C++ signature : void set_jump(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::kinematics::Jump)

set_jump_atom_stub_id( (AtomTree)arg1, (StubID)id) -> None : core/kinematics/AtomTree.hh:421

C++ signature : void set_jump_atom_stub_id(core::kinematics::AtomTree {lvalue},core::id::StubID)

set_jump_now( (AtomTree)arg1, (AtomID)id, (Jump)jump) -> None : set a specific jump transform and immediately refold downstream atoms

C++ signature : void set_jump_now(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::kinematics::Jump)

set_stub_transform( (AtomTree)arg1, (StubID)stub_id1, (StubID)stub_id2, (RT)target_rt) -> AtomID : Set the transform between two stubs, returns the atomid of the jump atom which moved (for book-keeping)

C++ signature : core::id::AtomID set_stub_transform(core::kinematics::AtomTree {lvalue},core::id::StubID,core::id::StubID,core::kinematics::RT)

set_torsion_angle( (AtomTree)arg1, (AtomID)atom1, (AtomID)atom2, (AtomID)atom3, (AtomID)atom4, (float)setting [, (bool)quiet=False]) -> DOF_ID : set a torsion angle "setting" to a specifc DOF derived by the four atoms

C++ signature : core::id::DOF_ID set_torsion_angle(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID,core::id::AtomID,core::id::AtomID,double [,bool=False])

set_weak_pointer_to_self( (AtomTree)arg1, (AtomTreeCAP)self_pointer) -> None : Weak-pointer setter. The object that instantiates an owning pointer to an AtomTree object must hand that AtomTree a weak pointer to itself so that the AtomTree may share that weak pointer with other AtomTrees. Such sharing allows for crucial speedups when copying between AtomTrees. If the object that instantiates this AtomTree does not provide it with a pointer-to-self, the AtomTree will still function, but it will not share its pointers properly.

C++ signature : void set_weak_pointer_to_self(core::kinematics::AtomTree {lvalue},boost::weak_ptr)

set_xyz( (AtomTree)arg1, (AtomID)id, (xyzVector_Real)xyz) -> None : set a specific atom xyz position

C++ signature : void set_xyz(core::kinematics::AtomTree {lvalue},core::id::AtomID,numeric::xyzVector)

size( (AtomTree)arg1) -> int : number of residues

C++ signature : unsigned long size(core::kinematics::AtomTree {lvalue})

stub_from_id( (AtomTree)arg1, (StubID)id) -> Stub : core/kinematics/AtomTree.hh:424

C++ signature : core::kinematics::Stub stub_from_id(core::kinematics::AtomTree {lvalue},core::id::StubID)

topological_match_to( (AtomTree)arg1) -> AtomTreeCAP : Functions only necessary for unit tests For testing purposes only: report the address of the AtomTree this tree is a topological copy of. The fact that AtomTrees keep track of other atom trees is "private" in the sense that no other class needs to worry about it. However, to test that the topological match algorithm is working properly, this private data needs to be readable. Do not use this function outside of the unit tests.

C++ signature : boost::weak_ptr topological_match_to(core::kinematics::AtomTree {lvalue})

topological_observers( (AtomTree)arg1) -> object : For testing purposes only: report the list of observer AtomTrees that are topological copies of this tree. The fact that AtomTrees keep track of other atom trees is "private" in the sense that no other class needs to worry about it. However, to test that the topological match algorithm is working properly, this private data needs to be readable. Do not use this function outside of the unit tests.

C++ signature : utility::vector1, std::allocator > > topological_observers(core::kinematics::AtomTree {lvalue})

torsion_angle( (AtomTree)arg1, (AtomID)atom1, (AtomID)atom2, (AtomID)atom3, (AtomID)atom4) -> float : calculate torsion angle defined by four atoms in the atom tree

C++ signature : double torsion_angle(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID,core::id::AtomID,core::id::AtomID)

torsion_angle_dof_id( (AtomTree)arg1, (AtomID)atom1, (AtomID)atom2, (AtomID)atom3, (AtomID)atom4 [, (bool)quiet=False]) -> DOF_ID : a wrapper function to get the DOF_ID of a torsion angle given those four atoms which define this torsion Another version of this function also calculates an offset value, which is not needed here.

C++ signature :
    core::id::DOF_ID torsion_angle_dof_id(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID,core::id::AtomID,core::id::AtomID [,bool=False])

torsion_angle_dof_id( (AtomTree)arg1, (AtomID)atom1_in_id, (AtomID)atom2_in_id, (AtomID)atom3_in_id, (AtomID)atom4_in_id, (float)offset [, (bool)quiet=False]) -> DOF_ID : get the DOF_ID of a torsion angle given those four atoms which define this torsion

C++ signature :
    core::id::DOF_ID torsion_angle_dof_id(core::kinematics::AtomTree {lvalue},core::id::AtomID,core::id::AtomID,core::id::AtomID,core::id::AtomID,double {lvalue} [,bool=False])

update_domain_map( (AtomTree)arg1, (object)domain_map, (AtomID_Map_T_bool_T)dof_moved, (AtomID_Map_T_bool_T)xyz_moved) -> None : generates a "domain_map" defining the rigid body regions whose internal coords have not changed, according to the informaiton in the two bool Mask's update domain map from dof_moved and xyz_moved

C++ signature : void update_domain_map(core::kinematics::AtomTree {lvalue},ObjexxFCL::FArray1D {lvalue},core::id::AtomID_Map,core::id::AtomID_Map)

update_sequence_numbering( (AtomTree)arg1, (int)new_size, (vector1_int)old2new) -> None : updates the Atom's AtomID's and the atom_pointer array

C++ signature : void update_sequence_numbering(core::kinematics::AtomTree {lvalue},unsigned long,utility::vector1 >)

xyz( (AtomTree)arg1, (AtomID)id) -> xyzVector_Real : get xyz position of an atom given its AtomID

C++ signature : numeric::xyzVector xyz(core::kinematics::AtomTree {lvalue},core::id::AtomID)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AtomTreeAP)arg1) -> AtomTree :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AtomTreeCAP)arg1) -> AtomTree :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (AtomID)atomid) -> None : core/kinematics/AtomWithDOFChange.hh:33

C++ signature :
    void __init__(_object*,core::id::AtomID)

init( (object)arg1, (AtomWithDOFChange)) -> None : simple class for use in output-sensitive refold subroutine.

C++ signature :
    void __init__(_object*,core::kinematics::AtomWithDOFChange)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AtomWithDOFChangeAP)arg1) -> AtomWithDOFChange :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AtomWithDOFChangeCAP)arg1) -> AtomWithDOFChange :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (str)msg, (FoldTree)f) -> None : core/kinematics/Exceptions.hh:40

C++ signature :
    void __init__(_object*,std::string,core::kinematics::FoldTree)

init( (object)arg1, (EXCN_InvalidFoldTree)) -> None : core/kinematics/Exceptions.hh:37

C++ signature :
    void __init__(_object*,core::kinematics::EXCN_InvalidFoldTree)

add_msg( (EXCN_InvalidFoldTree)arg1, (str)str) -> None : utility/excn/Exceptions.hh:66

C++ signature :
    void add_msg(core::kinematics::EXCN_InvalidFoldTree {lvalue},std::string)

add_msg( (EXCN_InvalidFoldTree)arg1, (str)str) -> None :

C++ signature :
    void add_msg(EXCN_InvalidFoldTree_exposer_callback {lvalue},std::string)

bad_tree( (EXCN_InvalidFoldTree)arg1) -> FoldTree : core/kinematics/Exceptions.hh:49

C++ signature : core::kinematics::FoldTree bad_tree(core::kinematics::EXCN_InvalidFoldTree {lvalue})

msg( (EXCN_InvalidFoldTree)arg1) -> str : utility/excn/Exceptions.hh:65

C++ signature :
    std::string msg(core::kinematics::EXCN_InvalidFoldTree {lvalue})

msg( (EXCN_InvalidFoldTree)arg1) -> str :

C++ signature :
    std::string msg(EXCN_InvalidFoldTree_exposer_callback {lvalue})

show( (EXCN_InvalidFoldTree)arg1, (OStream)os) -> None : core/kinematics/Exceptions.hh:45

C++ signature :
    void show(core::kinematics::EXCN_InvalidFoldTree {lvalue},std::ostream {lvalue})

show( (EXCN_InvalidFoldTree)arg1, (OStream)os) -> None :

C++ signature :
    void show(EXCN_InvalidFoldTree_exposer_callback {lvalue},std::ostream {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (EXCN_InvalidFoldTreeAP)arg1) -> EXCN_InvalidFoldTree :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (EXCN_InvalidFoldTreeCAP)arg1) -> EXCN_InvalidFoldTree :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (Edge)) -> None : //////////////////////////////////////////////////////////////////////////// \brief single edge of the fold_tree

 an edge is a path between two vertices(start and end residues). it can be
 either a continuous segment like a normal piece of polymer ("PEPTIDE" edge,
 index label as "-1"), a chemical connection between two residues ("CHEMICAL
 edge), or a rigid-body transformation between two residues ("JUMP" edge,
 index label as "1", "2",...). The edge is the basic unit of the fold tree
 as it stores info on how to build coordinates of the end residue given that
 of the starting residue and degrees of freedom between these two
 vertices.


C++ signature :
    void __init__(_object*,core::kinematics::Edge)

init( (object)arg1, (int)start_in, (int)stop_in, (int)label_in) -> None : constructor without atomno info

C++ signature :
    void __init__(_object*,int,int,int)

init( (object)arg1, (int)start_in, (int)stop_in, (str)start_atom, (str)stop_atom) -> None : CHEMICAL Edge constructor (requires atomno info) -- note: a chemical edge may be built from any constructor, this one is for convenience only

C++ signature :
    void __init__(_object*,int,int,std::string,std::string)

init( (object)arg1, (int)start_in, (int)stop_in, (int)label, (str)start_atom, (str)stop_atom, (bool)bKeepStubInResidue) -> None : JUMP Edge constructor (requires atomno info) -- note: a chemical edge may be built from any constructor, this one is for convenience only

C++ signature :
    void __init__(_object*,int,int,int,std::string,std::string,bool)

downstream_atom( (Edge)arg1) -> str : stop-atom, alt name, return by value

C++ signature :
    std::string downstream_atom(core::kinematics::Edge {lvalue})

downstream_atom( (Edge)arg1) -> str : stop-atom, alt name, return by reference

C++ signature :
    std::string {lvalue} downstream_atom(core::kinematics::Edge {lvalue})

has_atom_info( (Edge)arg1) -> bool : edge has start and stop atoms?

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

is_chemical_bond( (Edge)arg1) -> bool : core/kinematics/Edge.hh:187

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

is_jump( (Edge)arg1) -> bool : edge is a jump?

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

is_peptide( (Edge)arg1) -> bool : Edge is peptide edge? deprecated

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

is_polymer( (Edge)arg1) -> bool : Edge is peptide edge?

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

keep_stub_in_residue( (Edge)arg1) -> bool : core/kinematics/Edge.hh:219

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

keep_stub_in_residue( (Edge)arg1) -> bool : core/kinematics/Edge.hh:226

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

label( (Edge)arg1) -> int : label (edge type), return by value

C++ signature :
    int label(core::kinematics::Edge {lvalue})

label( (Edge)arg1) -> int : label (edge type), return by reference

C++ signature :
    int {lvalue} label(core::kinematics::Edge {lvalue})

polymer_direction( (Edge)arg1) -> int : direction for a continuous-segement edge. 1 if start residue number < stop residue number and -1 otherwise

C++ signature : int polymer_direction(core::kinematics::Edge {lvalue})

start( (Edge)arg1) -> int : ////////////////////////////////////////////////////////////////////////// start vertex, return by value

C++ signature :
    int start(core::kinematics::Edge {lvalue})

start( (Edge)arg1) -> int : start vertex, return by reference

C++ signature :
    int {lvalue} start(core::kinematics::Edge {lvalue})

start_atom( (Edge)arg1) -> str : start_atom, return by value

C++ signature :
    std::string start_atom(core::kinematics::Edge {lvalue})

start_atom( (Edge)arg1) -> str : start atom, return by reference

C++ signature :
    std::string {lvalue} start_atom(core::kinematics::Edge {lvalue})

stop( (Edge)arg1) -> int : stop vertex, return by value

C++ signature :
    int stop(core::kinematics::Edge {lvalue})

stop( (Edge)arg1) -> int : stop vertex, return by reference

C++ signature :
    int {lvalue} stop(core::kinematics::Edge {lvalue})

stop_atom( (Edge)arg1) -> str : stop_atom, return by value

C++ signature :
    std::string stop_atom(core::kinematics::Edge {lvalue})

stop_atom( (Edge)arg1) -> str : stop_atom, return by reference

C++ signature :
    std::string {lvalue} stop_atom(core::kinematics::Edge {lvalue})

upstream_atom( (Edge)arg1) -> str : start-atom, alt name, return by value

C++ signature :
    std::string upstream_atom(core::kinematics::Edge {lvalue})

upstream_atom( (Edge)arg1) -> str : start-atom, alt name, return by reference

C++ signature :
    std::string {lvalue} upstream_atom(core::kinematics::Edge {lvalue})

valid( (Edge)arg1) -> bool : Is this edge valid (false for default-constructed edges)

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

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (EdgeAP)arg1) -> Edge :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (EdgeCAP)arg1) -> Edge :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (FoldTree)) -> None : The FoldTree is a residue-based treelike representation of a molecule 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 @ref foldtree_overview "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

C++ signature :
    void __init__(_object*,core::kinematics::FoldTree)

init( (object)arg1, (int)nres_in) -> None : Constructs a simple FoldTree ft = FoldTree( nres_in ) int nres_in /the number of residues in this simple tree

C++ signature :
    void __init__(_object*,int)

add_edge( (FoldTree)arg1, (int)start, (int)stop, (int)label) -> None : Adds an edge from to

C++ signature :
    void add_edge(core::kinematics::FoldTree {lvalue},int,int,int)

add_edge( (FoldTree)arg1, (int)start, (int)stop, (str)start_atom, (str)stop_atom) -> None : Especially useful version of add_edge for chemical edge construction

C++ signature :
    void add_edge(core::kinematics::FoldTree {lvalue},int,int,std::string,std::string)

add_edge( (FoldTree)arg1, (Edge)new_edge) -> None : Add the 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

C++ signature :
    void add_edge(core::kinematics::FoldTree {lvalue},core::kinematics::Edge)

append_residue( (FoldTree)arg1 [, (bool)attach_by_jump=False [, (int)jump_anchor_residue=0 [, (str)jump_upstream_atom='' [, (str)jump_downstream_atom='']]]]) -> None : Appends a new residue to the tree, either by a jump or as a continuation of a peptide segment

C++ signature : void append_residue(core::kinematics::FoldTree {lvalue} [,bool=False [,int=0 [,std::string='' [,std::string='']]]])

append_residue_by_chemical_bond( (FoldTree)arg1, (int)anchor_residue, (str)anchor_atom, (str)root_atom) -> None : Appends a new residue to the tree using a chemical (APL-style) connection

C++ signature : void append_residue_by_chemical_bond(core::kinematics::FoldTree {lvalue},int,std::string,std::string)

apply_sequence_mapping( (FoldTree)arg1, (SequenceMapping)old2new) -> None : Renumber all vertices according to an input sequence mapping

C++ signature : void apply_sequence_mapping(core::kinematics::FoldTree {lvalue},core::id::SequenceMapping)

assign( (FoldTree)arg1, (FoldTree)src) -> FoldTree : operator= 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....

C++ signature : core::kinematics::FoldTree {lvalue} assign(core::kinematics::FoldTree {lvalue},core::kinematics::FoldTree)

begin( (FoldTree)arg1) -> object : begin iterator of the edge_list

C++ signature : gnu_cxx::normal_iterator > > begin(core::kinematics::FoldTree {lvalue})

boundary_left( (FoldTree)arg1, (int)res) -> int : Returns the starting residue of the kinematic chunk to which res belongs

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

boundary_right( (FoldTree)arg1, (int)res) -> int : Returns the ending residue of the kinematic chunk to which res belongs

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

check_edges_for_atom_info( (FoldTree)arg1) -> bool : chemical edges should have atom info

C++ signature : bool check_edges_for_atom_info(core::kinematics::FoldTree {lvalue})

check_fold_tree( (FoldTree)arg1) -> bool : 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

C++ signature : bool check_fold_tree(core::kinematics::FoldTree {lvalue})

clear( (FoldTree)arg1) -> None : Deletes all edge in the FoldTree example(s): ft.clear() See also: FoldTree FoldTree.add_edge FoldTree.check_fold_tree FoldTree.delete_edge FoldTree.new_jump FoldTree.nres FoldTree.num_jump FoldTree.simple_tree FoldTree.size

C++ signature : void clear(core::kinematics::FoldTree {lvalue})

clone( (FoldTree)arg1) -> FoldTree : core/kinematics/FoldTree.hh:109

C++ signature : core::kinematics::FoldTree clone(core::kinematics::FoldTree {lvalue})

connected( (FoldTree)arg1) -> bool : Returns true if the FoldTree is connected

C++ signature : bool connected(core::kinematics::FoldTree {lvalue})

count_fixed_residues( (FoldTree)arg1, (int)begin_res, (int)size, (int)min_edge_count_out) -> int : core/kinematics/FoldTree.hh:791

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

cutpoint( (FoldTree)arg1, (int)cut) -> int : ////////////////////////////////////////////////////////////////////////////

C++ signature : int cutpoint(core::kinematics::FoldTree {lvalue},int)

cutpoint_by_jump( (FoldTree)arg1, (int)jump_number) -> int : Returns the corresponding cutpoint position for jump 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

C++ signature : int cutpoint_by_jump(core::kinematics::FoldTree {lvalue},int)

cutpoint_map( (FoldTree)arg1, (int)seqpos) -> int : //////////////////////////////////////////////////////////////////////////// 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)

C++ signature : int cutpoint_map(core::kinematics::FoldTree {lvalue},int)

cutpoints( (FoldTree)arg1) -> vector1_int : get all cutpoints

C++ signature : utility::vector1 > cutpoints(core::kinematics::FoldTree {lvalue})

delete_edge( (FoldTree)arg1, (object)edge) -> None : Deletes the edge in the FoldTree by iterator

C++ signature :
    void delete_edge(core::kinematics::FoldTree {lvalue},__gnu_cxx::__normal_iterator<core::kinematics::Edge*, std::vector<core::kinematics::Edge, std::allocator<core::kinematics::Edge> > >)

delete_edge( (FoldTree)arg1, (Edge)edge) -> None : Delete the 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

C++ signature :
    void delete_edge(core::kinematics::FoldTree {lvalue},core::kinematics::Edge)

delete_extra_vertices( (FoldTree)arg1) -> None : Delete vertices that are no longer necessary any more How is this determined?

C++ signature : void delete_extra_vertices(core::kinematics::FoldTree {lvalue})

delete_jump_and_intervening_cutpoint( (FoldTree)arg1, (int)jump_begin, (int)jump_end) -> None : Useful for removing a loop modeling jump+cut

C++ signature :
    void delete_jump_and_intervening_cutpoint(core::kinematics::FoldTree {lvalue},int,int)

delete_jump_and_intervening_cutpoint( (FoldTree)arg1, (int)jump_number) -> None : Useful for removing a loop modeling jump+cut

C++ signature :
    void delete_jump_and_intervening_cutpoint(core::kinematics::FoldTree {lvalue},int)

delete_segment( (FoldTree)arg1, (int)seg_begin, (int)seg_end) -> None : Deletes a continuous segment from to 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

C++ signature : void delete_segment(core::kinematics::FoldTree {lvalue},int,int)

delete_self_edges( (FoldTree)arg1) -> None : Deletes edges with start==stop allowable 1->1 edge for single residue FoldTree

C++ signature : void delete_self_edges(core::kinematics::FoldTree {lvalue})

delete_seqpos( (FoldTree)arg1, (int)seqpos) -> None : Deletes the residue 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

C++ signature : void delete_seqpos(core::kinematics::FoldTree {lvalue},int)

delete_unordered_edge( (FoldTree)arg1, (int)start, (int)stop, (int)label) -> None : Find an edge in fold tree and delete it

C++ signature : void delete_unordered_edge(core::kinematics::FoldTree {lvalue},int,int,int)

downstream_atom( (FoldTree)arg1, (int)jump_number) -> str : the jump atom on the stopping side

C++ signature : std::string downstream_atom(core::kinematics::FoldTree {lvalue},int)

downstream_jump_residue( (FoldTree)arg1, (int)jump_number) -> int : the stopping residue for this jump

C++ signature : int downstream_jump_residue(core::kinematics::FoldTree {lvalue},int)

edge_label( (FoldTree)arg1, (int)start, (int)stop) -> int : Returns the edge label of the edge from to

C++ signature : int edge_label(core::kinematics::FoldTree {lvalue},int,int)

empty( (FoldTree)arg1) -> bool : 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

C++ signature : bool empty(core::kinematics::FoldTree {lvalue})

end( (FoldTree)arg1) -> object : end iterator of the edge_list

C++ signature : gnu_cxx::normal_iterator > > end(core::kinematics::FoldTree {lvalue})

get_jump_that_builds_residue( (FoldTree)arg1, (int)seqpos) -> int : Get the number of the jump that builds (connects to) a given residue

C++ signature : int get_jump_that_builds_residue(core::kinematics::FoldTree {lvalue},int)

get_outgoing_edges( (FoldTree)arg1, (int)seqpos) -> object : Returns all edges that build a residue directly off of

C++ signature : utility::vector1 > get_outgoing_edges(core::kinematics::FoldTree {lvalue},int)

get_parent_residue( (FoldTree)arg1, (int)seqpos, (bool)connected_by_jump) -> int : Get the residue that is immediately upstream of this residue (and tell us whether connection is jump or bond).

C++ signature :
    int get_parent_residue(core::kinematics::FoldTree {lvalue},int,bool {lvalue})

get_parent_residue( (FoldTree)arg1, (int)seqpos) -> int : Get the residue that is immediately upstream of this residue.

C++ signature :
    int get_parent_residue(core::kinematics::FoldTree {lvalue},int)

get_polymer_residue_direction( (FoldTree)arg1, (int)seqpos) -> int : Returns the direction (n2c, c2n) in which the given (peptide) residue is built during folding.

C++ signature : int get_polymer_residue_direction(core::kinematics::FoldTree {lvalue},int)

get_residue_edge( (FoldTree)arg1, (int)seqpos) -> Edge : Returns the edge that builds the residue Does not work for root atom (will fail)

C++ signature : core::kinematics::Edge get_residue_edge(core::kinematics::FoldTree {lvalue},int)

hash_value( (FoldTree)arg1) -> int : ////////////////////////// derived data ////////////////////// computes a fixed-length, hash-based identifier for this FoldTree, permitting efficient comparison between a pair of FoldTrees

C++ signature : unsigned long hash_value(core::kinematics::FoldTree {lvalue})

insert_fold_tree_by_jump( (FoldTree)arg1, (FoldTree)subtree, (int)insert_seqpos, (int)insert_jumppos, (int)anchor_pos [, (int)anchor_jump_number=0 [, (str)anchor_atom='' [, (str)root_atom='']]]) -> None : Inserts a fold_tree as a subtree

C++ signature : void insert_fold_tree_by_jump(core::kinematics::FoldTree {lvalue},core::kinematics::FoldTree,int,int,int [,int=0 [,std::string='' [,std::string='']]])

insert_polymer_residue( (FoldTree)arg1, (int)seqpos, (bool)join_lower, (bool)join_upper) -> None : Inserts a polymer residue at position How?

C++ signature : void insert_polymer_residue(core::kinematics::FoldTree {lvalue},int,bool,bool)

insert_residue_by_chemical_bond( (FoldTree)arg1, (int)seqpos, (int)anchor_residue, (str)anchor_atom, (str)root_atom) -> None : Inserts a bonded residue at position

C++ signature : void insert_residue_by_chemical_bond(core::kinematics::FoldTree {lvalue},int,int,std::string,std::string)

insert_residue_by_jump( (FoldTree)arg1, (int)seqpos, (int)anchor_pos [, (str)anchor_atom='' [, (str)root_atomno='']]) -> None : Inserts a residue attached only by a jump. precondition is that seqpos-1 is a cutpoint that anchor_pos is wrt the current numbering system (ie before insertion)

C++ signature : void insert_residue_by_jump(core::kinematics::FoldTree {lvalue},int,int [,std::string='' [,std::string='']])

is_cutpoint( (FoldTree)arg1, (int)seqpos) -> bool : ////////////////////////////////////////////////////////////////////////////

C++ signature : bool is_cutpoint(core::kinematics::FoldTree {lvalue},int)

is_jump_point( (FoldTree)arg1, (int)seqpos) -> bool : //////////////////////////////////////////////////////////////////////////// is seqpos a jump-point?

C++ signature : bool is_jump_point(core::kinematics::FoldTree {lvalue},int)

is_root( (FoldTree)arg1, (int)seqpos) -> bool : Returns true if the the root example(s): ft.empty() See also: FoldTree FoldTree.is_cutpoint FoldTree.is_jump_point FoldTree.nres

C++ signature : bool is_root(core::kinematics::FoldTree {lvalue},int)

is_simple_tree( (FoldTree)arg1) -> bool : Returns true if the FoldTree has 1-edge (non-jump) example(s): ft.is_simple_tree() See also: FoldTree FoldTree.check_fold_tree FoldTree.num_jump FoldTree.simple_tree

C++ signature : bool is_simple_tree(core::kinematics::FoldTree {lvalue})

jump_edge( (FoldTree)arg1, (int)jump_number) -> Edge : Returns the jump edge with jump number (const) example(s): ft.jump_edge(1) See also: FoldTree FoldTree.new_jump FoldTree.num_jump

C++ signature :
    core::kinematics::Edge jump_edge(core::kinematics::FoldTree {lvalue},int)

jump_edge( (FoldTree)arg1, (int)jump_number) -> Edge : Returns the jump edge with jump number (non-const)

C++ signature :
    core::kinematics::Edge {lvalue} jump_edge(core::kinematics::FoldTree {lvalue},int)

jump_exists( (FoldTree)arg1, (int)pos1, (int)pos2) -> bool : Return true if a jump exists between and example(s): ft.empty() See also: FoldTree FoldTree.check_fold_tree FoldTree.jump_edge FoldTree.new_jump FoldTree.nres

C++ signature : bool jump_exists(core::kinematics::FoldTree {lvalue},int,int)

jump_nr( (FoldTree)arg1, (int)pos1, (int)pos2) -> int : whether a jump exists between these residues

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

jump_point( (FoldTree)arg1, (int)lower_higher, (int)jump_number) -> int : starting or stopping residue of a jump edge

C++ signature : int jump_point(core::kinematics::FoldTree {lvalue},int,int)

new_chemical_bond( (FoldTree)arg1, (int)anchor_pos, (int)root_pos, (str)anchor_atom, (str)root_atom, (int)new_cutpoint) -> None : core/kinematics/FoldTree.hh:352

C++ signature : void new_chemical_bond(core::kinematics::FoldTree {lvalue},int,int,std::string,std::string,int)

new_jump( (FoldTree)arg1, (int)jump_pos1, (int)jump_pos2, (int)cutpoint) -> int : Adds a new jump edge from to with cutpoint

C++ signature : int new_jump(core::kinematics::FoldTree {lvalue},int,int,int)

nres( (FoldTree)arg1) -> int : //////////////////////////////////////////////////////////////////////////// routines for retrieving the derived data will call check_topology and/or check_order first

C++ signature : unsigned long nres(core::kinematics::FoldTree {lvalue})

num_cutpoint( (FoldTree)arg1) -> int : ////////////////////////////////////////////////////////////////////////////

C++ signature : int num_cutpoint(core::kinematics::FoldTree {lvalue})

num_jump( (FoldTree)arg1) -> int : ////////////////////////////////////////////////////////////////////////////

C++ signature : unsigned long num_jump(core::kinematics::FoldTree {lvalue})

partition_by_jump( (FoldTree)arg1, (int)jump_number, (FoldTree)f1, (FoldTree)f2) -> None : partition into two foldtrees by cutting at jump= jump_number

C++ signature :
    void partition_by_jump(core::kinematics::FoldTree {lvalue},int,core::kinematics::FoldTree {lvalue},core::kinematics::FoldTree {lvalue})

partition_by_jump( (FoldTree)arg1, (int)jump_number, (object)partner1) -> None : partition the fold tree in two parts if the jump is disconnected.

C++ signature :
    void partition_by_jump(core::kinematics::FoldTree {lvalue},int,ObjexxFCL::FArray1D<bool> {lvalue})

partition_by_jump( (FoldTree)arg1, (int)jump_nr) -> vector1_bool : partition the fold tree in two parts if the jump is disconnected.

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

partition_by_residue( (FoldTree)arg1, (int)seqpos, (object)partner1) -> None : partition the fold tree in two parts if a cut would be introduced between seqpos and seqpos+1

C++ signature : void partition_by_residue(core::kinematics::FoldTree {lvalue},int,ObjexxFCL::FArray1D {lvalue})

partition_coloring( (FoldTree)arg1, (vector1_Size)jump_numbers) -> vector1_Size : partition the fold tree into n parts based on specified jumps.

C++ signature : utility::vector1 > partition_coloring(core::kinematics::FoldTree {lvalue},utility::vector1 >)

possible_root( (FoldTree)arg1, (int)seqpos) -> bool : Returns true if is the root

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

prepend_edge( (FoldTree)arg1, (Edge)new_edge) -> None : Prepend the edge . Useful alternative to add_edge for setting root.

C++ signature : void prepend_edge(core::kinematics::FoldTree {lvalue},core::kinematics::Edge)

put_jump_stubs_intra_residue( (FoldTree)arg1) -> None : this reorganizes upstream/downstream atoms of all jumps such that stubs are N-CA-C

C++ signature : void put_jump_stubs_intra_residue(core::kinematics::FoldTree {lvalue})

random_tree_from_jump_points( (FoldTree)arg1, (int)nres_in, (int)num_jump_in, (object)jump_point, (object)cut_bias [, (int)root_in=1 [, (bool)allow_jump_at_1_or_NRES=False]]) -> bool : Builds a FoldTree from a list of and random cut points based on some biased probability Returns bool about success

C++ signature :
    bool random_tree_from_jump_points(core::kinematics::FoldTree {lvalue},int,int,ObjexxFCL::FArray2D<int>,ObjexxFCL::FArray1D<float> [,int=1 [,bool=False]])

random_tree_from_jump_points( (FoldTree)arg1, (int)nres_in, (int)num_jump_in, (object)jump_point, (std_vector_int)obligate_cut_points, (object)cut_bias [, (int)root_in=1 [, (bool)allow_jump_at_1_or_NRES=False]]) -> bool : Builds a FoldTree from a list of and random cut points based on some biased probability and any user-defined obligate cutpoints Returns bool about success

C++ signature :
    bool random_tree_from_jump_points(core::kinematics::FoldTree {lvalue},int,int,ObjexxFCL::FArray2D<int>,std::vector<int, std::allocator<int> >,ObjexxFCL::FArray1D<float> [,int=1 [,bool=False]])

reassign_atoms_for_intra_residue_stubs( (FoldTree)arg1) -> None : this reorganizes upstream/downstream atoms of jumps that have flag keep_stub_in_resiue = true such that stubs are N-CA-C

C++ signature : void reassign_atoms_for_intra_residue_stubs(core::kinematics::FoldTree {lvalue})

renumber_jumps( (FoldTree)arg1) -> None : Renumbers the jump edges in the FoldTree How?

C++ signature : void renumber_jumps(core::kinematics::FoldTree {lvalue})

reorder( (FoldTree)arg1, (int)start_residue [, (bool)verbose_if_fail=True]) -> bool : Reorders the FoldTree to start at residue

C++ signature : bool reorder(core::kinematics::FoldTree {lvalue},int [,bool=True])

root( (FoldTree)arg1) -> int : Returns the root vertex position of the FoldTree example(s): ft.empty() See also: FoldTree FoldTree.is_root FoldTree.clear FoldTree.simple_tree

C++ signature : int root(core::kinematics::FoldTree {lvalue})

set_jump_atoms( (FoldTree)arg1, (int)jump_number, (str)upstream_atom, (str)downstream_atom [, (bool)bKeepStubInResidue=False]) -> None : define the specific atoms that should be connected by this jump

C++ signature :
    void set_jump_atoms(core::kinematics::FoldTree {lvalue},int,std::string,std::string [,bool=False])

set_jump_atoms( (FoldTree)arg1, (int)jump_number, (int)res1, (str)atom1, (int)res2, (str)atom2 [, (bool)bKeepStubInResidue=False]) -> None : core/kinematics/FoldTree.hh:569

C++ signature :
    void set_jump_atoms(core::kinematics::FoldTree {lvalue},int,unsigned long,std::string,unsigned long,std::string [,bool=False])

show( (FoldTree)arg1, (OStream)out) -> None : Displays the FoldTree information example(s): ft.show() See Also: Pose

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

simple_tree( (FoldTree)arg1, (int)nres_in) -> None : Produces a 1-edge FoldTree that is long No jumps or extraneous features example(s): ft.simple_tree() See also: FoldTree FoldTree.add_edge FoldTree.check_fold_tree FoldTree.clear FoldTree.delete_edge FoldTree.is_simple_tree FoldTree.new_jump FoldTree.nres FoldTree.num_jump FoldTree.size

C++ signature : void simple_tree(core::kinematics::FoldTree {lvalue},int)

size( (FoldTree)arg1) -> int : Returns the number of edges in the FoldTree example(s): ft.size() See also: FoldTree FoldTree.add_edge FoldTree.check_fold_tree FoldTree.delete_edge FoldTree.jump_edge FoldTree.nres FoldTree.num_jump

C++ signature : int size(core::kinematics::FoldTree {lvalue})

slide_cutpoint( (FoldTree)arg1, (int)current_cut, (int)target_cut) -> None : Slide a polymer cutpoint from one location to another

C++ signature : void slide_cutpoint(core::kinematics::FoldTree {lvalue},unsigned long,unsigned long)

slide_jump( (FoldTree)arg1, (int)jump_number, (int)new_res1, (int)new_res2) -> None : change an existing jump to start and end in new positions

C++ signature : void slide_jump(core::kinematics::FoldTree {lvalue},unsigned long,unsigned long,unsigned long)

to_string( (FoldTree)arg1) -> str : easy output of string

C++ signature : std::string to_string(core::kinematics::FoldTree {lvalue})

tree_from_jumps_and_cuts( (FoldTree)arg1, (int)nres_in, (int)num_jump_in, (object)jump_point, (object)cuts [, (int)root_in=1 [, (bool)verbose=False]]) -> bool : Constructs a FoldTree from listed and Returns bool about success

C++ signature : bool tree_from_jumps_and_cuts(core::kinematics::FoldTree {lvalue},int,int,ObjexxFCL::FArray2D,ObjexxFCL::FArray1D [,int=1 [,bool=False]])

update_edge_label( (FoldTree)arg1, (int)start, (int)stop, (int)old_label, (int)new_label) -> None : Changes the label of an edge in fold tree

C++ signature : void update_edge_label(core::kinematics::FoldTree {lvalue},int,int,int,int)

upstream_atom( (FoldTree)arg1, (int)jump_number) -> str : the jump atom on the staring side

C++ signature : std::string upstream_atom(core::kinematics::FoldTree {lvalue},int)

upstream_jump_residue( (FoldTree)arg1, (int)jump_number) -> int : the staring residue for this jump

C++ signature : int upstream_jump_residue(core::kinematics::FoldTree {lvalue},int)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FoldTreeAP)arg1) -> FoldTree :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (FoldTreeCAP)arg1) -> FoldTree :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (RT)src_rt) -> None : constructor with only RT

C++ signature :
    void __init__(_object*,core::kinematics::RT)

init( (object)arg1, (Stub)stub1, (Stub)stub2) -> None : get RT from two stubs and ZERO rb_delta

C++ signature :
    void __init__(_object*,core::kinematics::Stub,core::kinematics::Stub)

init( (object)arg1, (Jump)src) -> None : copy constructor

C++ signature :
    void __init__(_object*,core::kinematics::Jump)

assign( (Jump)arg1, (Jump)src) -> Jump : copy operator

C++ signature : core::kinematics::Jump {lvalue} assign(core::kinematics::Jump {lvalue},core::kinematics::Jump)

fold_in_rb_deltas( (Jump)arg1) -> None : transform small changes in translation and rotation into jump

C++ signature : void fold_in_rb_deltas(core::kinematics::Jump {lvalue})

from_bond_cst( (Jump)arg1, (vector1_xyzVector_Real)atoms, (vector1_Real)csts) -> None : get a jump from a bond cst definition

C++ signature : void from_bond_cst(core::kinematics::Jump {lvalue},utility::vector1, std::allocator > > {lvalue},utility::vector1 >)

from_stubs( (Jump)arg1, (Stub)stub1, (Stub)stub2) -> None : get a jump from two stubs

C++ signature : void from_stubs(core::kinematics::Jump {lvalue},core::kinematics::Stub,core::kinematics::Stub)

gaussian_move( (Jump)arg1, (int)dir, (float)trans_mag, (float)rot_mag) -> vector1_Real : Given the desired magnitude of the translation and rotation components, applies Gaussian perturbation to this jump. Return the move that was applied

C++ signature : utility::vector1 > gaussian_move(core::kinematics::Jump {lvalue},int,float,float)

gaussian_move_single_rb( (Jump)arg1, (int)dir, (float)mag, (int)rb) -> None : core/kinematics/Jump.hh:137

C++ signature : void gaussian_move_single_rb(core::kinematics::Jump {lvalue},int,float,int)

get_rb_center( (Jump)arg1, (int)dir) -> xyzVector_Real : ////////////////////////////////////////////////////////////////////////////

C++ signature : numeric::xyzVector get_rb_center(core::kinematics::Jump {lvalue},int)

get_rb_delta( (Jump)arg1, (int)dir) -> vector1_Real : //////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////

C++ signature :
    utility::vector1<double, std::allocator<double> > get_rb_delta(core::kinematics::Jump {lvalue},int)

get_rb_delta( (Jump)arg1, (int)rb_no, (int)dir) -> float : ////////////////////////////////////////////////////////////////////////////

C++ signature :
    double get_rb_delta(core::kinematics::Jump {lvalue},int,int)

get_rotation( (Jump)arg1) -> xyzMatrix_Real : //////////////////////////////////////////////////////////////////////////// inline definitions for Jump class

C++ signature : numeric::xyzMatrix get_rotation(core::kinematics::Jump {lvalue})

get_translation( (Jump)arg1) -> xyzVector_Real : ////////////////////////////////////////////////////////////////////////////

C++ signature : numeric::xyzVector get_translation(core::kinematics::Jump {lvalue})

identity_transform( (Jump)arg1) -> None : reset to identity matrix, 0 translation

C++ signature : void identity_transform(core::kinematics::Jump {lvalue})

make_jump( (Jump)arg1, (Stub)stub1, (Stub)stub2) -> None : make a jump from stub1 to stub2

C++ signature : void make_jump(core::kinematics::Jump {lvalue},core::kinematics::Stub,core::kinematics::Stub {lvalue})

nonzero_deltas( (Jump)arg1) -> bool : check whether there is rb_delta not being transformed.

C++ signature : bool nonzero_deltas(core::kinematics::Jump {lvalue})

ortho_check( (Jump)arg1) -> bool : check RT's orthogonality

C++ signature : bool ortho_check(core::kinematics::Jump {lvalue})

random_trans( (Jump)arg1, (float)dist_in) -> None : translate along a randomly chosen vector by dist_in

C++ signature : void random_trans(core::kinematics::Jump {lvalue},float)

reset( (Jump)arg1) -> None : reset RT, rb_delta and rb_center

C++ signature : void reset(core::kinematics::Jump {lvalue})

reverse( (Jump)arg1) -> None : change the direction of a jump, e.g, upstream stub becomes downstream stub now.

C++ signature : void reverse(core::kinematics::Jump {lvalue})

reversed( (Jump)arg1) -> Jump : Return a new jump that is the inverse transformation

C++ signature : core::kinematics::Jump reversed(core::kinematics::Jump {lvalue})

rotation_by_axis( (Jump)arg1, (Stub)stub, (xyzVector_Real)axis, (xyzVector_Real)center, (float)alpha) -> None : make a rotation of alpha degrees around axix and center

C++ signature : void rotation_by_axis(core::kinematics::Jump {lvalue},core::kinematics::Stub,numeric::xyzVector,numeric::xyzVector,float)

rotation_by_matrix( (Jump)arg1, (Stub)stub, (xyzVector_Real)center, (xyzMatrix_Real)matrix) -> None : make a rotation "matrix" about the center "center"

C++ signature : void rotation_by_matrix(core::kinematics::Jump {lvalue},core::kinematics::Stub,numeric::xyzVector,numeric::xyzMatrix)

rt( (Jump)arg1) -> RT : return the RT modeled by this jump --> makes new Jump, calls fold_in_rb_delte and returns RT

C++ signature : core::kinematics::RT rt(core::kinematics::Jump {lvalue})

set_rb_center( (Jump)arg1, (int)dir, (Stub)stub, (xyzVector_Real)center) -> None : set rb_center by direction

C++ signature : void set_rb_center(core::kinematics::Jump {lvalue},int,core::kinematics::Stub,numeric::xyzVector)

set_rb_delta( (Jump)arg1, (int)rb_no, (int)dir, (float)value) -> None : set rb_delta by direction and rb_number

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

set_rb_deltas( (Jump)arg1, (int)dir, (vector1_Real)) -> None : set rb_deltas by direction

C++ signature : void set_rb_deltas(core::kinematics::Jump {lvalue},int,utility::vector1 >)

set_rotation( (Jump)arg1, (xyzMatrix_Real)R_in) -> None : set rotation matrix

C++ signature : void set_rotation(core::kinematics::Jump {lvalue},numeric::xyzMatrix)

set_translation( (Jump)arg1, (xyzVector_Real)t) -> None : set translation vector

C++ signature : void set_translation(core::kinematics::Jump {lvalue},numeric::xyzVector)

translation_along_axis( (Jump)arg1, (Stub)stub, (xyzVector_Real)axis, (float)dist) -> None : make a translation along axis by dist

C++ signature : void translation_along_axis(core::kinematics::Jump {lvalue},core::kinematics::Stub,numeric::xyzVector,float)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (JumpAP)arg1) -> Jump :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (JumpCAP)arg1) -> Jump :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

add_atom( (MinimizerMapBase)arg1, (AtomID)atom_id, (DOF_ID)dof_id) -> None : Allow the AtomTree to inform this class that a particular atom belongs in the derivative calculation for a certain DOF. That certain DOF must have already been included in the minimization process through a prior invocation of the add_torsion method.

C++ signature :
    void add_atom(core::kinematics::MinimizerMapBase {lvalue},core::id::AtomID,core::id::DOF_ID)

add_atom( (MinimizerMapBase)arg1, (AtomID)arg2, (DOF_ID)arg3) -> None :

C++ signature :
    void add_atom(boost::shared_ptr<MinimizerMapBase_exposer_callback> {lvalue},core::id::AtomID,core::id::DOF_ID)

add_torsion( (MinimizerMapBase)arg1, (DOF_ID)new_torsion, (DOF_ID)parent) -> None : Allow the AtomTree to communicate to this class that a particular torsion (or angle or distance -- a particular DOF) belongs in the minimization task to inform this class the parent DOF for that torsion.

C++ signature :
    void add_torsion(core::kinematics::MinimizerMapBase {lvalue},core::id::DOF_ID,core::id::DOF_ID)

add_torsion( (MinimizerMapBase)arg1, (DOF_ID)arg2, (DOF_ID)arg3) -> None :

C++ signature :
    void add_torsion(boost::shared_ptr<MinimizerMapBase_exposer_callback> {lvalue},core::id::DOF_ID,core::id::DOF_ID)

domain_map( (MinimizerMapBase)arg1) -> object : core/kinematics/MinimizerMapBase.hh:178

C++ signature :
    ObjexxFCL::FArray1D<int> domain_map(core::kinematics::MinimizerMapBase {lvalue})

domain_map( (MinimizerMapBase)arg1) -> None :

C++ signature :
    void domain_map(boost::shared_ptr<MinimizerMapBase_exposer_callback> {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MinimizerMapBaseAP)arg1) -> MinimizerMapBase :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MinimizerMapBaseCAP)arg1) -> MinimizerMapBase :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (MoveMap)) -> None : A class specifying DOFs to be flexible or fixed currently there are two groups of data, one is residue-based Torsion definition, such as BB, CHI, NU, and JUMP; the other is atom-based DOF definition, such as bond length D, bond angle THETA and torsion angle PHI which are used in atom-tree. MoveMap does not automatically handle conversion from one group to the other, i.e., setting PHI false for DOF_type does not affect setting for BB and CHI torsion though they are PHIs in atom-tree. within each group, there are multiple levels of control (from general/high to specific/lower): Torsion-based: TorsionType(BB, CHI, NU, JUMP) -> MoveMapTorsionID (BB, CHI of one residue) -> TorsionID ( BB torsion 2 or CHI torsion 3 of one residue) DOF-base: DOF_type( D, THETA, PHI ) -> DOF_ID (D, THETA, PHI of one atom) setting for each level are stored in a map structure and they are only added to the map when setting methods are invoked. As a result, MoveMap does not behave like a "Boolean vector" which always contains setting for each residue or atom in a conformation. Setting for a higher level will override setting for lower levels (remove it from map); Similarly, when querying a lower level finds no setting, it will check setting for its higher level. For example, setting TorsionType BB to be true will remove any data of BB setting for a residue or a specific BB torsion ( such as backbone psi ) in a residue. And querying setting for BB torsion 2 of residue 4 will first check if there is any specific setting, if not, check if there is a setting for all BB torsions for residue 4, if not again, use setting for BB torsions for all residues. example: movemap = MoveMap() See also: Pose MinMover ShearMover SmallMover

C++ signature :
    void __init__(_object*,core::kinematics::MoveMap)

clear( (MoveMap)arg1) -> None : clear -- sets all to FALSE

C++ signature : void clear(core::kinematics::MoveMap {lvalue})

clone( (MoveMap)arg1) -> MoveMap : core/kinematics/MoveMap.hh:124

C++ signature : boost::shared_ptr clone(core::kinematics::MoveMap {lvalue})

dof_id_begin( (MoveMap)arg1) -> object : return an iterator pointing at the first element of the DOF_ID_Map

C++ signature : std::_Rb_tree_const_iterator > dof_id_begin(core::kinematics::MoveMap {lvalue})

dof_id_end( (MoveMap)arg1) -> object : return an iterator pointing just past the last element of the DOF_ID_Map

C++ signature : std::_Rb_tree_const_iterator > dof_id_end(core::kinematics::MoveMap {lvalue})

dof_type_begin( (MoveMap)arg1) -> object : return an iterator pointing just past the last element of the DOF_TypeMap

C++ signature : std::_Rb_tree_const_iterator > dof_type_begin(core::kinematics::MoveMap {lvalue})

dof_type_end( (MoveMap)arg1) -> object : return an iterator pointing at the first element of the DOF_TypeMap

C++ signature : std::_Rb_tree_const_iterator > dof_type_end(core::kinematics::MoveMap {lvalue})

find( (MoveMap)arg1, (TorsionType)t) -> object : find the explicit setting for the given TorsionType iterator pointing to the TorsionType-bool pair, otherwise torsion_type_end() @warning Do not use this for general lookup, as it does not take into account the stringency levels. Only use this when you need to check if a setting explicitly exists.

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<core::id::TorsionType const, bool> > find(core::kinematics::MoveMap {lvalue},core::id::TorsionType)

find( (MoveMap)arg1, (object)id) -> object : find the explicit setting for the given MoveMapTorsionID iterator pointing to the MoveMapTorsionID-bool pair, otherwise movemap_torsion_id_end() @warning Do not use this for general lookup, as it does not take into account the stringency levels. Only use this when you need to check if a setting explicitly exists.

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<std::pair<unsigned long, core::id::TorsionType> const, bool> > find(core::kinematics::MoveMap {lvalue},std::pair<unsigned long, core::id::TorsionType>)

find( (MoveMap)arg1, (TorsionID)id) -> object : find the explicit setting for the given TorsionID iterator pointing to the TorsionID-bool pair, otherwise torsion_id_end() @warning Do not use this for general lookup, as it does not take into account the stringency levels. Only use this when you need to check if a setting explicitly exists.

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<core::id::TorsionID const, bool> > find(core::kinematics::MoveMap {lvalue},core::id::TorsionID)

find( (MoveMap)arg1, (JumpID)jump) -> object : find the explicit setting for the given JumpID iterator pointing to the JumpID-bool pair, otherwise jump_id_end() @warning Do not use this for general lookup, as it does not take into account the stringency levels. Only use this when you need to check if a setting explicitly exists.

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<core::id::JumpID const, bool> > find(core::kinematics::MoveMap {lvalue},core::id::JumpID)

find( (MoveMap)arg1, (DOF_Type)t) -> object : find the explicit setting for the given DOF_Type iterator pointing to the DOF_Type-bool pair, otherwise dof_type_end() @warning Do not use this for general lookup, as it does not take into account the stringency levels. Only use this when you need to check if a setting explicitly exists.

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<core::id::DOF_Type const, bool> > find(core::kinematics::MoveMap {lvalue},core::id::DOF_Type)

find( (MoveMap)arg1, (DOF_ID)id) -> object : find the explicit setting for the given DOF_ID iterator pointing to the DOF_ID-bool pair, otherwise dof_id_end() @warning Do not use this for general lookup, as it does not take into account the stringency levels. Only use this when you need to check if a setting explicitly exists.

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<core::id::DOF_ID const, bool> > find(core::kinematics::MoveMap {lvalue},core::id::DOF_ID)

get( (MoveMap)arg1, (TorsionType)t) -> bool : get setting for a specific TorsionType, such as "BB"

C++ signature :
    bool get(core::kinematics::MoveMap {lvalue},core::id::TorsionType)

get( (MoveMap)arg1, (object)id) -> bool : get TorsionType flexible or fixed for one residue, eg BB torsions for residue 10

C++ signature :
    bool get(core::kinematics::MoveMap {lvalue},std::pair<unsigned long, core::id::TorsionType>)

get( (MoveMap)arg1, (TorsionID)id) -> bool : core/kinematics/MoveMap.hh:488

C++ signature :
    bool get(core::kinematics::MoveMap {lvalue},core::id::TorsionID)

get( (MoveMap)arg1, (DOF_Type)t) -> bool : get the default for this type of DOF, eg "PHI"

C++ signature :
    bool get(core::kinematics::MoveMap {lvalue},core::id::DOF_Type)

get( (MoveMap)arg1, (DOF_ID)id) -> bool : get the setting for an individual dof, eg, PHI of Atom 3 in Residue 5

C++ signature :
    bool get(core::kinematics::MoveMap {lvalue},core::id::DOF_ID)

get_bb( (MoveMap)arg1, (int)seqpos) -> bool : Returns if BB torsions are movable or not for residue example: movemap.get_bb(49)

C++ signature : bool get_bb(core::kinematics::MoveMap {lvalue},unsigned long)

get_chi( (MoveMap)arg1, (int)seqpos) -> bool : Returns if SC torsions are movable or not for residue example: movemap.get_chi(49)

C++ signature : bool get_chi(core::kinematics::MoveMap {lvalue},int)

get_jump( (MoveMap)arg1, (int)jump_number) -> bool : Returns if JUMP is movable or not example: movemap.get_jump(1)

C++ signature :
    bool get_jump(core::kinematics::MoveMap {lvalue},int)

get_jump( (MoveMap)arg1, (int)pos1, (int)pos2) -> bool : core/kinematics/MoveMap.hh:471

C++ signature :
    bool get_jump(core::kinematics::MoveMap {lvalue},unsigned long,unsigned long)

get_jump( (MoveMap)arg1, (JumpID)jump) -> bool : core/kinematics/MoveMap.hh:477

C++ signature :
    bool get_jump(core::kinematics::MoveMap {lvalue},core::id::JumpID)

get_nu( (MoveMap)arg1, (int)seqpos) -> bool : Return if NU torsions are movable or not for residue . : Example: movemap.get_nu(49)

C++ signature : bool get_nu(core::kinematics::MoveMap {lvalue},unsigned long)

import( (MoveMap)arg1, (MoveMap)rval) -> int : import settings from another MoveMap The total number of settings imported. @remarks This function calls set() for each setting that exists in the 'rval' MoveMap in order from lowest to highest stringency.

C++ signature : unsigned long import(core::kinematics::MoveMap {lvalue},core::kinematics::MoveMap)

import_false( (MoveMap)arg1, (MoveMap)rval) -> int : import only False settings from another MoveMap The total number of settings imported. @remarks This function calls set() for each setting that is marked as False in the 'rval' MoveMap in order from lowest to highest stringency.

C++ signature : unsigned long import_false(core::kinematics::MoveMap {lvalue},core::kinematics::MoveMap)

import_true( (MoveMap)arg1, (MoveMap)rval) -> int : import only True settings from another MoveMap The total number of settings imported. @remarks This function calls set() for each setting that is marked as True in the 'rval' MoveMap in order from lowest to highest stringency.

C++ signature : unsigned long import_true(core::kinematics::MoveMap {lvalue},core::kinematics::MoveMap)

init_from_file( (MoveMap)arg1, (str)filename) -> None : Read MoveMap from file.

C++ signature : void init_from_file(core::kinematics::MoveMap {lvalue},std::string)

jump_id_begin( (MoveMap)arg1) -> object : return an iterator pointing at the first element of the JumpID_Map

C++ signature : std::_Rb_tree_const_iterator > jump_id_begin(core::kinematics::MoveMap {lvalue})

jump_id_end( (MoveMap)arg1) -> object : return an iterator pointing just past the last element of the JumpID_Map

C++ signature : std::_Rb_tree_const_iterator > jump_id_end(core::kinematics::MoveMap {lvalue})

movemap_torsion_id_begin( (MoveMap)arg1) -> object : return an iterator pointing at the first element of the MoveMapTorsionID_Map

C++ signature : std::_Rb_tree_const_iterator const, bool> > movemap_torsion_id_begin(core::kinematics::MoveMap {lvalue})

movemap_torsion_id_end( (MoveMap)arg1) -> object : return an iterator pointing just past the last element of the MoveMapTorsionID_Map

C++ signature : std::_Rb_tree_const_iterator const, bool> > movemap_torsion_id_end(core::kinematics::MoveMap {lvalue})

set( (MoveMap)arg1, (TorsionType)t, (bool)setting) -> None : set a specific TorsionType movable: currently BB, CHI, NU, or JUMP

C++ signature :
    void set(core::kinematics::MoveMap {lvalue},core::id::TorsionType,bool)

set( (MoveMap)arg1, (object)id, (bool)setting) -> None : set TorsionType flexible or fixed for one residue, e.g., BB torsions for residue 10

C++ signature :
    void set(core::kinematics::MoveMap {lvalue},std::pair<unsigned long, core::id::TorsionType>,bool)

set( (MoveMap)arg1, (TorsionID)id, (bool)setting) -> None : set an individual Torsion movable for now, e.g., "BB torsion 2 of residue 4"

C++ signature :
    void set(core::kinematics::MoveMap {lvalue},core::id::TorsionID,bool)

set( (MoveMap)arg1, (DOF_Type)t, (bool)setting) -> None : set atom tree DOF, e.g., D, PHI, THETA

C++ signature :
    void set(core::kinematics::MoveMap {lvalue},core::id::DOF_Type,bool)

set( (MoveMap)arg1, (DOF_ID)id, (bool)setting) -> None : set for an individual DoF, e.g., "PHI of Atom 3 in Residue 5"

C++ signature :
    void set(core::kinematics::MoveMap {lvalue},core::id::DOF_ID,bool)

set_bb( (MoveMap)arg1, (bool)setting) -> None : Set whether or not BB TorsionType is moveable example: movemap.set_bb(True) See also: MoveMap MoveMap.set_chi MoveMap.set_nu Pose MinMover ShearMover SmallMover

C++ signature :
    void set_bb(core::kinematics::MoveMap {lvalue},bool)

set_bb( (MoveMap)arg1, (int)seqpos, (bool)setting) -> None : Sets whether or not the BB torsions of residue are movable example: movemap.set_bb(49,True) See also: MoveMap MoveMap.set_chi MoveMap.set_nu Pose MinMover ShearMover SmallMover

C++ signature :
    void set_bb(core::kinematics::MoveMap {lvalue},unsigned long,bool)

set_bb( (MoveMap)arg1, (vector1_bool)allow_bb) -> None : Sets BB torsions movable based on input array

C++ signature :
    void set_bb(core::kinematics::MoveMap {lvalue},utility::vector1<bool, std::allocator<bool> >)

set_bb_true_range( (MoveMap)arg1, (int)begin, (int)end) -> None : Sets the BB torsions between residues and as movable, all other residues are non-movable example: movemap.set_bb_true_range(40,60) See also: MoveMap MoveMap.set_bb MoveMap.set_chi MoveMap.set_nu Pose MinMover ShearMover SmallMover

C++ signature : void set_bb_true_range(core::kinematics::MoveMap {lvalue},unsigned long,unsigned long)

set_chi( (MoveMap)arg1, (bool)setting) -> None : Sets whether or not CHI TorsionType is movable example: movemap.set_chi(True) See also: MoveMap MoveMap.set_bb MoveMap.set_nu Pose MinMover ShearMover SmallMover

C++ signature :
    void set_chi(core::kinematics::MoveMap {lvalue},bool)

set_chi( (MoveMap)arg1, (int)seqpos, (bool)setting) -> None : Sets whether or not the CHI torsions of residue are movable example: movemap.set_chi(49,True) See also: MoveMap MoveMap.set_bb MoveMap.set_nu Pose MinMover ShearMover SmallMover inline

C++ signature :
    void set_chi(core::kinematics::MoveMap {lvalue},unsigned long,bool)

set_chi( (MoveMap)arg1, (vector1_bool)allow_chi) -> None : set CHI torsions movable based on input array

C++ signature :
    void set_chi(core::kinematics::MoveMap {lvalue},utility::vector1<bool, std::allocator<bool> >)

set_chi_true_range( (MoveMap)arg1, (int)begin, (int)end) -> None : Sets the chi torsions between residues and as movable and all other residues are non-movable. Example: movemap.set_chi_true_range(40, 60) See also: MoveMap MoveMap.set_bb MoveMap.set_bb_true_range MoveMap.set_chi MoveMap.set_nu MoveMap.set_nu_true_range Pose MinMover ShearMover SmallMover

C++ signature : void set_chi_true_range(core::kinematics::MoveMap {lvalue},unsigned long,unsigned long)

set_jump( (MoveMap)arg1, (bool)setting) -> None : Sets whether or not JUMP TorsionType is moveable example: movemap.set_jump(True)

C++ signature :
    void set_jump(core::kinematics::MoveMap {lvalue},bool)

set_jump( (MoveMap)arg1, (int)jump_number, (bool)setting) -> None : Sets the movability of JUMP to example: movemap.set_jump(1,True)

C++ signature :
    void set_jump(core::kinematics::MoveMap {lvalue},int,bool)

set_jump( (MoveMap)arg1, (int)pos1, (int)pos2, (bool)setting) -> None : set JUMP moveable or not for one specific residue pair this mechanism does not mix with the "jump_nr" mechanism... i.e., if you set jump_nr 3 = movable ---> movemap does not know that this refers to say residue 23-89

C++ signature :
    void set_jump(core::kinematics::MoveMap {lvalue},unsigned long,unsigned long,bool)

set_jump( (MoveMap)arg1, (JumpID)jump, (bool)setting) -> None : core/kinematics/MoveMap.hh:400

C++ signature :
    void set_jump(core::kinematics::MoveMap {lvalue},core::id::JumpID,bool)

set_nu( (MoveMap)arg1, (bool)setting) -> None : Set whether or not NU TorsionTypes are movable. Example: movemap.set_nu(True)\n See also:\n MoveMap\n MoveMap.set_bb\n MoveMap.set_chi\n Pose\n MinMover\n ShearMover\n SmallMover

C++ signature :
    void set_nu(core::kinematics::MoveMap {lvalue},bool)

set_nu( (MoveMap)arg1, (int)seqpos, (bool)setting) -> None : Set whether or not the NU torsions of residue are movable. Example: movemap.set_nu(49, True)\n See also:\n MoveMap\n MoveMap.set_bb\n MoveMap.set_chi\n Pose\n MinMover\n ShearMover\n SmallMover

C++ signature :
    void set_nu(core::kinematics::MoveMap {lvalue},unsigned long,bool)

set_nu_true_range( (MoveMap)arg1, (int)begin, (int)end) -> None : Set the NU torsions between residues and as movable and all other residues are non-movable. Example: movemap.set_nu_true_range(40, 60)\n See also:\n MoveMap\n MoveMap.set_bb\n MoveMap.set_bb_true_range\n MoveMap.set_chi\n MoveMap.set_chi_true_range\n MoveMap.set_nu\n Pose\n MinMover\n ShearMover\n SmallMover

C++ signature : void set_nu_true_range(core::kinematics::MoveMap {lvalue},unsigned long,unsigned long)

set_nus( (MoveMap)arg1, (vector1_bool)settings) -> None : Set which NU torsions are movable based on input array.

C++ signature : void set_nus(core::kinematics::MoveMap {lvalue},utility::vector1 >)

set_ranges_unmodifiable( (MoveMap)arg1, (object)ranges) -> None : Prevents backbone torsion modifications to the intervals specified by . Each element of the vector is a pair, which specifies the begin and end indices. Counting begins with 1.

C++ signature : void set_ranges_unmodifiable(core::kinematics::MoveMap {lvalue},std::vector, std::allocator > >)

show( (MoveMap)arg1, (OStream)out, (int)i) -> None : gives the BB and CHI bool values up to a given residue number

C++ signature :
    void show(core::kinematics::MoveMap {lvalue},std::ostream {lvalue},unsigned long)

show( (MoveMap)arg1, (int)i) -> None : gives the BB and CHI bool values up to a given residue number wrapper for PyRosetta

C++ signature :
    void show(core::kinematics::MoveMap {lvalue},unsigned long)

show( (MoveMap)arg1, (OStream)out) -> None : core/kinematics/MoveMap.hh:655

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

show( (MoveMap)arg1) -> None : core/kinematics/MoveMap.hh:658

C++ signature :
    void show(core::kinematics::MoveMap {lvalue})

torsion_id_begin( (MoveMap)arg1) -> object : return an iterator pointing at the first element of the TorsionID_Map

C++ signature : std::_Rb_tree_const_iterator > torsion_id_begin(core::kinematics::MoveMap {lvalue})

torsion_id_end( (MoveMap)arg1) -> object : return an iterator pointing just past the last element of the TorsionID_Map

C++ signature : std::_Rb_tree_const_iterator > torsion_id_end(core::kinematics::MoveMap {lvalue})

torsion_type_begin( (MoveMap)arg1) -> object : return an iterator pointing just past the last element of the TorsionTypeMap

C++ signature : std::_Rb_tree_const_iterator > torsion_type_begin(core::kinematics::MoveMap {lvalue})

torsion_type_end( (MoveMap)arg1) -> object : return an iterator pointing at the first element of the TorsionTypeMap

C++ signature : std::_Rb_tree_const_iterator > torsion_type_end(core::kinematics::MoveMap {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MoveMapAP)arg1) -> MoveMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MoveMapCAP)arg1) -> MoveMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (xyzMatrix_Real)rot, (xyzVector_Real)vec) -> None : matrix/vector constructor

C++ signature :
    void __init__(_object*,numeric::xyzMatrix<double>,numeric::xyzVector<double>)

init( (object)arg1, (Stub)stub1, (Stub)stub2) -> None : construct from two stubs

C++ signature :
    void __init__(_object*,core::kinematics::Stub,core::kinematics::Stub)

init( (object)arg1, (RT)src) -> None : copy constructor

C++ signature :
    void __init__(_object*,core::kinematics::RT)

assign( (RT)arg1, (RT)src) -> RT : copy operator

C++ signature : core::kinematics::RT {lvalue} assign(core::kinematics::RT {lvalue},core::kinematics::RT)

distance_squared( (RT)arg1, (RT)b) -> float : core/kinematics/RT.hh:162

C++ signature : double distance_squared(core::kinematics::RT {lvalue},core::kinematics::RT)

fold_in_rb_deltas( (RT)arg1, (vector1_Real)rb, (xyzVector_Real)rb_center) -> None : update the transform to include small additional rigid-body rotations and translations PHIL: IT WOULD BE GOOD TO ELIMINATE ARGUMENT ARRAYS IN MINI BY USE OF APPROPRIATE LAYERED DATA STRUCTURES

C++ signature : void fold_in_rb_deltas(core::kinematics::RT {lvalue},utility::vector1 >,numeric::xyzVector)

from_stubs( (RT)arg1, (Stub)stub1, (Stub)stub2) -> None : update from stubs

C++ signature : void from_stubs(core::kinematics::RT {lvalue},core::kinematics::Stub,core::kinematics::Stub)

get_rotation( (RT)arg1) -> xyzMatrix_Real : get the rotation

C++ signature : numeric::xyzMatrix get_rotation(core::kinematics::RT {lvalue})

get_translation( (RT)arg1) -> xyzVector_Real : get the translation

C++ signature : numeric::xyzVector get_translation(core::kinematics::RT {lvalue})

identity_transform( (RT)arg1) -> None : return to default-constructed state (another name)

C++ signature : void identity_transform(core::kinematics::RT {lvalue})

inverse( (RT)arg1) -> None : reverse the "view"

C++ signature : void inverse(core::kinematics::RT {lvalue})

make_jump( (RT)arg1, (Stub)stub1, (Stub)stub2) -> None : should be inverse of RT::from_stubs

C++ signature : void make_jump(core::kinematics::RT {lvalue},core::kinematics::Stub,core::kinematics::Stub {lvalue})

ortho_check( (RT)arg1) -> bool : check for orthogonality

C++ signature : bool ortho_check(core::kinematics::RT {lvalue})

reset( (RT)arg1) -> None : return to default-constructed state

C++ signature : void reset(core::kinematics::RT {lvalue})

reverse( (RT)arg1) -> None : reverse the "view"

C++ signature : void reverse(core::kinematics::RT {lvalue})

set_rotation( (RT)arg1, (xyzMatrix_Real)r) -> None : set the rotation

C++ signature : void set_rotation(core::kinematics::RT {lvalue},numeric::xyzMatrix)

set_translation( (RT)arg1, (xyzVector_Real)t) -> None : set the tranlsation

C++ signature : void set_translation(core::kinematics::RT {lvalue},numeric::xyzVector)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (RTAP)arg1) -> RT :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (RTCAP)arg1) -> RT :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (ResidueCoordinateChangeList)) -> None : The AtomTree is responsible for informing the conformation of which residues have had either internal (DOF) or external (xyz) coordinate changes so that the Conformation may shuttle O(k) -- output sensitive -- data from the AtomTree to the Residue objects it manages.

C++ signature :
    void __init__(_object*,core::kinematics::ResidueCoordinateChangeList)

assign( (ResidueCoordinateChangeList)arg1, (ResidueCoordinateChangeList)rhs) -> ResidueCoordinateChangeList : core/kinematics/ResidueCoordinateChangeList.hh:44

C++ signature : core::kinematics::ResidueCoordinateChangeList assign(core::kinematics::ResidueCoordinateChangeList {lvalue},core::kinematics::ResidueCoordinateChangeList)

clear( (ResidueCoordinateChangeList)arg1) -> None : Reset the list of those residues that have moved. O(k).

C++ signature : void clear(core::kinematics::ResidueCoordinateChangeList {lvalue})

empty( (ResidueCoordinateChangeList)arg1) -> bool : Is the list of the changed residues empty?

C++ signature : bool empty(core::kinematics::ResidueCoordinateChangeList {lvalue})

mark_residue_moved( (ResidueCoordinateChangeList)arg1, (AtomID)atid) -> None : Mark a residue as having changed by passing in an AtomId for one atom in that residue

C++ signature :
    void mark_residue_moved(core::kinematics::ResidueCoordinateChangeList {lvalue},core::id::AtomID)

mark_residue_moved( (ResidueCoordinateChangeList)arg1, (int)resid) -> None : Mark a residue as having changed by passing in the index of that residue.

C++ signature :
    void mark_residue_moved(core::kinematics::ResidueCoordinateChangeList {lvalue},unsigned long)

residues_moved_begin( (ResidueCoordinateChangeList)arg1) -> object : returns an iterator to the beginning of the (unordered) list of residues that have moved.

C++ signature : gnu_cxx::normal_iterator > > residues_moved_begin(core::kinematics::ResidueCoordinateChangeList {lvalue})

residues_moved_end( (ResidueCoordinateChangeList)arg1) -> object : returns an iterator to the end of the (unordered) list of residues that have moved.

C++ signature : gnu_cxx::normal_iterator > > residues_moved_end(core::kinematics::ResidueCoordinateChangeList {lvalue})

total_residue( (ResidueCoordinateChangeList)arg1, (int)total_residue) -> None : Set the number of residues in the conformation being tracked.

C++ signature :
    void total_residue(core::kinematics::ResidueCoordinateChangeList {lvalue},unsigned long)

total_residue( (ResidueCoordinateChangeList)arg1) -> int : Return the number of

C++ signature :
    unsigned long total_residue(core::kinematics::ResidueCoordinateChangeList {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ResidueCoordinateChangeListAP)arg1) -> ResidueCoordinateChangeList :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ResidueCoordinateChangeListCAP)arg1) -> ResidueCoordinateChangeList :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (FoldTree)f) -> None : cs-tor, parses fold-tree and caches important distances: memory N^2+M*5 N: 2 x number of jumps M: number of residues

C++ signature :
    void __init__(_object*,core::kinematics::FoldTree)

init( (object)arg1, (ShortestPathInFoldTree)) -> None : core/kinematics/ShortestPathInFoldTree.hh:48

C++ signature :
    void __init__(_object*,core::kinematics::ShortestPathInFoldTree)

dist( (ShortestPathInFoldTree)arg1, (int)pos1, (int)pos2) -> int : returns the shortest distance of two residues going along Fold-Tree edges.

C++ signature : unsigned long dist(core::kinematics::ShortestPathInFoldTree {lvalue},unsigned long,unsigned long)

max_dist( (ShortestPathInFoldTree)arg1) -> int : returns the shortest distance for the two residues that are furthest apart

C++ signature : unsigned long max_dist(core::kinematics::ShortestPathInFoldTree {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ShortestPathInFoldTreeAP)arg1) -> ShortestPathInFoldTree :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ShortestPathInFoldTreeCAP)arg1) -> ShortestPathInFoldTree :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (Stub)) -> None : ////////////////////////////////////////////////////////////////////////// Stub class -- an object of orthogonal coordinate frame

 an orthogonal coord frame M (matrix) centered at point V (vector),
 defined by four points, one is for the center and the other three for
 calculating the orthogonal frame. For example, a stub can be derived from
 a backbone triplet N-CA-C centered at CA.

 See @ref atomtree_overview "AtomTree overview and concepts" for details.


C++ signature :
    void __init__(_object*,core::kinematics::Stub)

init( (object)arg1, (xyzMatrix_Real)M_in, (xyzVector_Real)v_in) -> None : copy constructor

C++ signature :
    void __init__(_object*,numeric::xyzMatrix<double>,numeric::xyzVector<double>)

init( (object)arg1, (RT)rt) -> None : constructor from RT object

C++ signature :
    void __init__(_object*,core::kinematics::RT)

init( (object)arg1, (xyzVector_Real)center, (xyzVector_Real)a, (xyzVector_Real)b, (xyzVector_Real)c) -> None : constructor by four points first point is the center (V) and the rest three are used to construct the coord frame (M). see member function from_four_points(...) construct a stub centered at v_in, as would come from building c then b then a

C++ signature :
    void __init__(_object*,numeric::xyzVector<double>,numeric::xyzVector<double>,numeric::xyzVector<double>,numeric::xyzVector<double>)

init( (object)arg1, (xyzVector_Real)a, (xyzVector_Real)b, (xyzVector_Real)c) -> None : constructor by three points first point is the center (V) and all the three are used to construct the coord frame (M). see member functon from_four_points(...) construct a stub as would come from building c then b then a

C++ signature :
    void __init__(_object*,numeric::xyzVector<double>,numeric::xyzVector<double>,numeric::xyzVector<double>)

build_fake_xyz( (Stub)arg1, (int)index) -> xyzVector_Real : Build stubatom coords that would yield this stub

C++ signature : numeric::xyzVector build_fake_xyz(core::kinematics::Stub {lvalue},unsigned long)

center( (Stub)arg1) -> xyzVector_Real : Coordinate frame center.

C++ signature : numeric::xyzVector center(core::kinematics::Stub {lvalue})

from_four_points( (Stub)arg1, (xyzVector_Real)center, (xyzVector_Real)a, (xyzVector_Real)b, (xyzVector_Real)c) -> None : build a stub from a center and other three points a, b, c

C++ signature : void from_four_points(core::kinematics::Stub {lvalue},numeric::xyzVector,numeric::xyzVector,numeric::xyzVector,numeric::xyzVector)

global2local( (Stub)arg1, (xyzVector_Real)xyz) -> xyzVector_Real : convert a global reference (lab) frame vector to our local (stub) frame

C++ signature : numeric::xyzVector global2local(core::kinematics::Stub {lvalue},numeric::xyzVector)

is_orthogonal( (Stub)arg1, (float)tolerance) -> bool : check if the stub is orthogonal under the tolerance cutoff

C++ signature : bool is_orthogonal(core::kinematics::Stub {lvalue},double)

local2global( (Stub)arg1, (xyzVector_Real)xyz) -> xyzVector_Real : convert a local reference (stub) frame vector to the global (lab) frame

C++ signature : numeric::xyzVector local2global(core::kinematics::Stub {lvalue},numeric::xyzVector)

rotation( (Stub)arg1) -> xyzMatrix_Real : Coordinate frame rotation matrix.

C++ signature : numeric::xyzMatrix rotation(core::kinematics::Stub {lvalue})

spherical( (Stub)arg1, (float)phi, (float)theta, (float)d) -> xyzVector_Real : Build a vector in the global lab frame from the spherical coords used in the atomtree theta is the angle between the postive x and the vector (0<=theta<=pi), phi is the angle between the y-z plane projection of the vector and the positive y (0<=theta<=2*pi), d is the length of the vector These are non-standard in the choice of axis for historical reasons --PB

C++ signature : numeric::xyzVector spherical(core::kinematics::Stub {lvalue},double,double,double)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (StubAP)arg1) -> Stub :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (StubCAP)arg1) -> Stub :

C++ signature : boost::shared_ptr get(boost::weak_ptr)