Python: module rosetta.core.kinematics

rosetta.core.kinematics

index
(built-in)

Bindings for core::kinematics namespace

Modules

rosetta.core.kinematics.tree

Classes



builtins.object

AtomTree
AtomWithDOFChange
Edge
FoldTree
Jump
MinimizerMapBase
MoveMap
RT
ResidueCoordinateChangeList
ShortestPathInFoldTree
Stub

rosetta.utility.excn.EXCN_Msg_Exception(rosetta.utility.excn.EXCN_Exception)

EXCN_InvalidFoldTree

class AtomTree(builtins.object)

    The AtomTree class is a wrapper for a tree of kinematic Atoms. The responsibilities of the class are: 1. Maintain a map from AtomIDs to Atoms for fast lookup. 2. Keep the internal and xyz coords of the Atoms in sync.    Note that this sync'ing is handled    in a lazy fashion, analogous to the way the current pose handles    refolding. As a result, getting and setting of coords can trigger    coordinate updates. 3. Gatekeep modification of internal or xyz coords for the Atoms    (necessary for #2). 4. Serve out the xyz coords for updating a Pose/Conformation object. 5. Identify DOF_IDs that correspond to torsion angles (e.g., phi, psi, chi, nu)    specified by 4 AtomIDs. Do this in a way that enables fast    lookup, e.g., caching the results of previous calls (?).    Note that some torsions will not correspond exactly to a DOF of    an Atom; e.g., chi1 when we are folding c->n, necessitating    calculation of an offset. We should be able to handle getting/setting    of these torsion angles as well as handing back the DOF_ID    (the last one is necessary when setting up the DOF_IDMask for    minimization given a MoveMap object). See

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.kinematics.AtomTree, rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) -> NoneType doc 2. __init__(self : rosetta.core.kinematics.AtomTree, new_atom_pointer : rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t, from_xyz : bool) -> NoneType 3. __init__(rosetta.core.kinematics.AtomTree) -> NoneType 4. __init__(self : rosetta.core.kinematics.AtomTree, src : rosetta.core.kinematics.AtomTree) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.AtomTree, src : rosetta.core.kinematics.AtomTree) -> rosetta.core.kinematics.AtomTree Copy assignment. If these two AtomTrees do not know anything about each other, then this function makes this AtomTree a complete copy of the src AtomTree, and then keeps track of the fact that the topology of the trees are identical by keeping a (raw) pointer to the src AtomTree and letting the src AtomTree keep a (raw) pointer to it.  The next time this AtomTree's topology changes, or the next time the src AtomTree's topology changes, the "observer" connection between the two of them is severed -- each AtomTree getting modified. This is not a thread-safe operation! If the AtomTree's have matching topologies, then this function simply iterates across all the atoms in both trees and copies the DOFs and coordinates from src into this.

atom(...) from builtins.PyCapsule
atom(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.AtomID) -> rosetta.core.kinematics.tree.Atom

atom_dont_do_update(...) from builtins.PyCapsule
atom_dont_do_update(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.AtomID) -> rosetta.core.kinematics.tree.Atom

batch_set_xyz(...) from builtins.PyCapsule
batch_set_xyz(self : rosetta.core.kinematics.AtomTree, id : rosetta.utility.vector1_core_id_AtomID, xyz : rosetta.utility.vector1_numeric_xyzVector_double_t) -> NoneType simultaniously set several atom xyz positions

bond_angle(...) from builtins.PyCapsule
bond_angle(self : rosetta.core.kinematics.AtomTree, atom1 : rosetta.core.id.AtomID, atom2 : rosetta.core.id.AtomID, atom3 : rosetta.core.id.AtomID) -> float

bond_angle_dof_id(...) from builtins.PyCapsule
bond_angle_dof_id(self : rosetta.core.kinematics.AtomTree, atom1_in_id : rosetta.core.id.AtomID, atom2_in_id : rosetta.core.id.AtomID, atom3_in_id : rosetta.core.id.AtomID, offset : float) -> rosetta.core.id.DOF_ID get the DOF_ID of a bond angle given those 3 atoms which define this torsion

bond_length(...) from builtins.PyCapsule
bond_length(self : rosetta.core.kinematics.AtomTree, atom1 : rosetta.core.id.AtomID, atom2 : rosetta.core.id.AtomID) -> float

bond_length_dof_id(...) from builtins.PyCapsule
bond_length_dof_id(self : rosetta.core.kinematics.AtomTree, atom1_in_id : rosetta.core.id.AtomID, atom2_in_id : rosetta.core.id.AtomID) -> rosetta.core.id.DOF_ID get the DOF_ID of a bond length given those 2 atoms which define this torsion

clear(...) from builtins.PyCapsule
clear(rosetta.core.kinematics.AtomTree) -> NoneType clear the content of an AtomTree object, delete root atom and all pointers

copy_coords(...) from builtins.PyCapsule
copy_coords(self : rosetta.core.kinematics.AtomTree, src : rosetta.core.kinematics.AtomTree) -> NoneType copy the internal and xyz coords from src tree, which should have the same topology as me

delete_seqpos(...) from builtins.PyCapsule
delete_seqpos(self : rosetta.core.kinematics.AtomTree, seqpos : int) -> NoneType 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

detached_copy(...) from builtins.PyCapsule
detached_copy(self : rosetta.core.kinematics.AtomTree, src : rosetta.core.kinematics.AtomTree) -> NoneType Copy assignment that first invokes operator =, and then immediately severs the connection between the src and this AtomTrees.  This function modifies the src AtomTree briefly while it executes, but then makes sure that there is no further (behind the sceens) communication between the two trees (e.g. that might happen when the topology of one of the trees changes, so that the "topological match to" status has to be severed).

dof(...) from builtins.PyCapsule
dof(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.DOF_ID) -> float get value of DOF( PHI, THETA, D, RB1, ....)  given its DOF_ID

empty(...) from builtins.PyCapsule
empty(rosetta.core.kinematics.AtomTree) -> bool is there any atom in the tree yet?

get_jump_atom_id(...) from builtins.PyCapsule
get_jump_atom_id(self : rosetta.core.kinematics.AtomTree, stub_id1 : rosetta.core.id.StubID, stub_id2 : rosetta.core.id.StubID, direction : int) -> rosetta.core.id.AtomID find the atom giving rise to the jump connecting two stubs. is set to 1 or -1 depending on the direction of the jump

get_stub_transform(...) from builtins.PyCapsule
get_stub_transform(self : rosetta.core.kinematics.AtomTree, stub_id1 : rosetta.core.id.StubID, stub_id2 : rosetta.core.id.StubID) -> rosetta.core.kinematics.RT get the transform between two stubs

has(...) from builtins.PyCapsule
has(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.AtomID) -> 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

jump(...) from builtins.PyCapsule
jump(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.AtomID) -> rosetta.core.kinematics.Jump

note_coordinate_change_registered(...) from builtins.PyCapsule
note_coordinate_change_registered(rosetta.core.kinematics.AtomTree) -> NoneType 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

promote_sameresidue_nonjump_child(...) from builtins.PyCapsule
promote_sameresidue_nonjump_child(self : rosetta.core.kinematics.AtomTree, parent_atom_id : rosetta.core.id.AtomID) -> NoneType Useful for guaranteeing that a stub remains within a single residue

replace_tree(...) from builtins.PyCapsule
replace_tree(*args, **kwargs) Overloaded function. 1. replace_tree(self : rosetta.core.kinematics.AtomTree, new_atom_pointer : rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) -> NoneType replaces the entire tree 2. replace_tree(self : rosetta.core.kinematics.AtomTree, new_atom_pointer : rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t, from_xyz : bool) -> NoneType replaces the entire tree

residue_xyz_change_list_begin(...) from builtins.PyCapsule
residue_xyz_change_list_begin(rosetta.core.kinematics.AtomTree) -> __gnu_cxx::__normal_iterator<unsigned long const*, std::vector<unsigned long, std::allocator<unsigned long> > > 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

residue_xyz_change_list_end(...) from builtins.PyCapsule
residue_xyz_change_list_end(rosetta.core.kinematics.AtomTree) -> __gnu_cxx::__normal_iterator<unsigned long const*, std::vector<unsigned long, std::allocator<unsigned long> > >

root(...) from builtins.PyCapsule
root(rosetta.core.kinematics.AtomTree) -> rosetta.core.kinematics.tree.Atom const-access to the root of the tree

set_bond_angle(...) from builtins.PyCapsule
set_bond_angle(self : rosetta.core.kinematics.AtomTree, atom1 : rosetta.core.id.AtomID, atom2 : rosetta.core.id.AtomID, atom3 : rosetta.core.id.AtomID, setting : float) -> rosetta.core.id.DOF_ID

set_bond_length(...) from builtins.PyCapsule
set_bond_length(self : rosetta.core.kinematics.AtomTree, atom1 : rosetta.core.id.AtomID, atom2 : rosetta.core.id.AtomID, setting : float) -> rosetta.core.id.DOF_ID

set_dof(...) from builtins.PyCapsule
set_dof(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.DOF_ID, setting : float) -> NoneType set a specific DOF in the tree

set_jump(...) from builtins.PyCapsule
set_jump(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.AtomID, jump : rosetta.core.kinematics.Jump) -> NoneType set a specific jump transform

set_jump_atom_stub_id(...) from builtins.PyCapsule
set_jump_atom_stub_id(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.StubID) -> NoneType

set_jump_now(...) from builtins.PyCapsule
set_jump_now(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.AtomID, jump : rosetta.core.kinematics.Jump) -> NoneType set a specific jump transform and immediately refold downstream atoms

set_stub_transform(...) from builtins.PyCapsule
set_stub_transform(self : rosetta.core.kinematics.AtomTree, stub_id1 : rosetta.core.id.StubID, stub_id2 : rosetta.core.id.StubID, target_rt : rosetta.core.kinematics.RT) -> rosetta.core.id.AtomID Set the transform between two stubs, returns the atomid of the jump atom which moved (for book-keeping)

set_torsion_angle(...) from builtins.PyCapsule
set_torsion_angle(*args, **kwargs) Overloaded function. 1. set_torsion_angle(self : rosetta.core.kinematics.AtomTree, atom1 : rosetta.core.id.AtomID, atom2 : rosetta.core.id.AtomID, atom3 : rosetta.core.id.AtomID, atom4 : rosetta.core.id.AtomID, setting : float) -> rosetta.core.id.DOF_ID set a torsion angle "setting" to a specifc DOF derived by the four atoms 2. set_torsion_angle(self : rosetta.core.kinematics.AtomTree, atom1 : rosetta.core.id.AtomID, atom2 : rosetta.core.id.AtomID, atom3 : rosetta.core.id.AtomID, atom4 : rosetta.core.id.AtomID, setting : float, quiet : bool) -> rosetta.core.id.DOF_ID set a torsion angle "setting" to a specifc DOF derived by the four atoms

set_weak_pointer_to_self(...) from builtins.PyCapsule
set_weak_pointer_to_self(self : rosetta.core.kinematics.AtomTree, self_pointer : rosetta.std.weak_ptr_const_core_kinematics_AtomTree_t) -> NoneType 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.

set_xyz(...) from builtins.PyCapsule
set_xyz(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.AtomID, xyz : rosetta.numeric.xyzVector_double_t) -> NoneType set a specific atom xyz position

size(...) from builtins.PyCapsule
size(rosetta.core.kinematics.AtomTree) -> int number of residues

stub_from_id(...) from builtins.PyCapsule
stub_from_id(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.StubID) -> rosetta.core.kinematics.Stub

topological_match_to(...) from builtins.PyCapsule
topological_match_to(rosetta.core.kinematics.AtomTree) -> rosetta.std.weak_ptr_const_core_kinematics_AtomTree_t 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.

topological_observers(...) from builtins.PyCapsule
topological_observers(rosetta.core.kinematics.AtomTree) -> rosetta.utility.vector1_std_weak_ptr_const_core_kinematics_AtomTree_t 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.

torsion_angle(...) from builtins.PyCapsule
torsion_angle(self : rosetta.core.kinematics.AtomTree, atom1 : rosetta.core.id.AtomID, atom2 : rosetta.core.id.AtomID, atom3 : rosetta.core.id.AtomID, atom4 : rosetta.core.id.AtomID) -> float calculate torsion angle defined by four atoms in the atom tree

torsion_angle_dof_id(...) from builtins.PyCapsule
torsion_angle_dof_id(*args, **kwargs) Overloaded function. 1. torsion_angle_dof_id(self : rosetta.core.kinematics.AtomTree, atom1 : rosetta.core.id.AtomID, atom2 : rosetta.core.id.AtomID, atom3 : rosetta.core.id.AtomID, atom4 : rosetta.core.id.AtomID) -> rosetta.core.id.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. 2. torsion_angle_dof_id(self : rosetta.core.kinematics.AtomTree, atom1 : rosetta.core.id.AtomID, atom2 : rosetta.core.id.AtomID, atom3 : rosetta.core.id.AtomID, atom4 : rosetta.core.id.AtomID, quiet : bool) -> rosetta.core.id.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. 3. torsion_angle_dof_id(self : rosetta.core.kinematics.AtomTree, atom1_in_id : rosetta.core.id.AtomID, atom2_in_id : rosetta.core.id.AtomID, atom3_in_id : rosetta.core.id.AtomID, atom4_in_id : rosetta.core.id.AtomID, offset : float) -> rosetta.core.id.DOF_ID get the DOF_ID of a torsion angle given those four atoms which define this torsion 4. torsion_angle_dof_id(self : rosetta.core.kinematics.AtomTree, atom1_in_id : rosetta.core.id.AtomID, atom2_in_id : rosetta.core.id.AtomID, atom3_in_id : rosetta.core.id.AtomID, atom4_in_id : rosetta.core.id.AtomID, offset : float, quiet : bool) -> rosetta.core.id.DOF_ID get the DOF_ID of a torsion angle given those four atoms which define this torsion

update_domain_map(...) from builtins.PyCapsule
update_domain_map(self : rosetta.core.kinematics.AtomTree, domain_map : ObjexxFCL::FArray1D<int>, dof_moved : rosetta.core.id.AtomID_Map_bool_t, xyz_moved : rosetta.core.id.AtomID_Map_bool_t) -> NoneType 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

update_sequence_numbering(...) from builtins.PyCapsule
update_sequence_numbering(self : rosetta.core.kinematics.AtomTree, new_size : int, old2new : rosetta.utility.vector1_int) -> NoneType updates the Atom's AtomID's and the atom_pointer array

xyz(...) from builtins.PyCapsule
xyz(self : rosetta.core.kinematics.AtomTree, id : rosetta.core.id.AtomID) -> rosetta.numeric.xyzVector_double_t get xyz position of an atom given its AtomID

class AtomWithDOFChange(builtins.object)

    simple class for use in output-sensitive refold subroutine.

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : rosetta.core.kinematics.AtomWithDOFChange, atomid : rosetta.core.id.AtomID) -> NoneType 2. __init__(rosetta.core.kinematics.AtomWithDOFChange) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

Data descriptors defined here:

atomid_

reached_

class EXCN_InvalidFoldTree(rosetta.utility.excn.EXCN_Msg_Exception)


Method resolution order:

EXCN_InvalidFoldTree

rosetta.utility.excn.EXCN_Msg_Exception

rosetta.utility.excn.EXCN_Exception

rosetta.utility.excn.EXCN_Base

builtins.object

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : handle, msg : str, f : rosetta.core.kinematics.FoldTree) -> NoneType 2. __init__(handle, rosetta.core.kinematics.EXCN_InvalidFoldTree) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.EXCN_InvalidFoldTree,  : rosetta.core.kinematics.EXCN_InvalidFoldTree) -> rosetta.core.kinematics.EXCN_InvalidFoldTree

bad_tree(...) from builtins.PyCapsule
bad_tree(rosetta.core.kinematics.EXCN_InvalidFoldTree) -> rosetta.core.kinematics.FoldTree

Methods inherited from rosetta.utility.excn.EXCN_Msg_Exception:

add_msg(...) from builtins.PyCapsule
add_msg(self : rosetta.utility.excn.EXCN_Msg_Exception, str : str) -> NoneType

msg(...) from builtins.PyCapsule
msg(rosetta.utility.excn.EXCN_Msg_Exception) -> str

Methods inherited from rosetta.utility.excn.EXCN_Base:

__str__(...) from builtins.PyCapsule
__str__(rosetta.utility.excn.EXCN_Base) -> str

class Edge(builtins.object)

    //////////////////////////////////////////////////////////////////////////// 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.

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.kinematics.Edge) -> NoneType 2. __init__(self : rosetta.core.kinematics.Edge, start_in : int, stop_in : int, label_in : int) -> NoneType 3. __init__(self : rosetta.core.kinematics.Edge, start_in : int, stop_in : int, start_atom : str, stop_atom : str) -> NoneType 4. __init__(self : rosetta.core.kinematics.Edge, start_in : int, stop_in : int, label : int, start_atom : str, stop_atom : str, bKeepStubInResidue : bool) -> NoneType 5. __init__(self : rosetta.core.kinematics.Edge,  : rosetta.core.kinematics.Edge) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

__str__(...) from builtins.PyCapsule
__str__(rosetta.core.kinematics.Edge) -> str

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.Edge,  : rosetta.core.kinematics.Edge) -> rosetta.core.kinematics.Edge

downstream_atom(...) from builtins.PyCapsule
downstream_atom(*args, **kwargs) Overloaded function. 1. downstream_atom(rosetta.core.kinematics.Edge) -> str stop-atom, alt name, return by value 2. downstream_atom(rosetta.core.kinematics.Edge) -> str stop-atom, alt name, return by reference

has_atom_info(...) from builtins.PyCapsule
has_atom_info(rosetta.core.kinematics.Edge) -> bool edge has start and stop atoms?

is_chemical_bond(...) from builtins.PyCapsule
is_chemical_bond(rosetta.core.kinematics.Edge) -> bool

is_jump(...) from builtins.PyCapsule
is_jump(rosetta.core.kinematics.Edge) -> bool edge is a jump?

is_peptide(...) from builtins.PyCapsule
is_peptide(rosetta.core.kinematics.Edge) -> bool Edge is peptide edge? deprecated

is_polymer(...) from builtins.PyCapsule
is_polymer(rosetta.core.kinematics.Edge) -> bool Edge is peptide edge?

keep_stub_in_residue(...) from builtins.PyCapsule
keep_stub_in_residue(*args, **kwargs) Overloaded function. 1. keep_stub_in_residue(rosetta.core.kinematics.Edge) -> bool 2. keep_stub_in_residue(rosetta.core.kinematics.Edge) -> bool

label(...) from builtins.PyCapsule
label(*args, **kwargs) Overloaded function. 1. label(rosetta.core.kinematics.Edge) -> int label (edge type), return by value 2. label(rosetta.core.kinematics.Edge) -> int label (edge type), return by reference

polymer_direction(...) from builtins.PyCapsule
polymer_direction(rosetta.core.kinematics.Edge) -> int direction for a continuous-segement edge. 1 if start residue number < stop residue number and -1 otherwise

start(...) from builtins.PyCapsule
start(*args, **kwargs) Overloaded function. 1. start(rosetta.core.kinematics.Edge) -> int start vertex, return by value 2. start(rosetta.core.kinematics.Edge) -> int start vertex, return by reference

start_atom(...) from builtins.PyCapsule
start_atom(*args, **kwargs) Overloaded function. 1. start_atom(rosetta.core.kinematics.Edge) -> str start_atom, return by value 2. start_atom(rosetta.core.kinematics.Edge) -> str start atom, return by reference

stop(...) from builtins.PyCapsule
stop(*args, **kwargs) Overloaded function. 1. stop(rosetta.core.kinematics.Edge) -> int stop vertex, return by value 2. stop(rosetta.core.kinematics.Edge) -> int stop vertex, return by reference

stop_atom(...) from builtins.PyCapsule
stop_atom(*args, **kwargs) Overloaded function. 1. stop_atom(rosetta.core.kinematics.Edge) -> str stop_atom, return by value 2. stop_atom(rosetta.core.kinematics.Edge) -> str stop_atom, return by reference

upstream_atom(...) from builtins.PyCapsule
upstream_atom(*args, **kwargs) Overloaded function. 1. upstream_atom(rosetta.core.kinematics.Edge) -> str start-atom, alt name, return by value 2. upstream_atom(rosetta.core.kinematics.Edge) -> str start-atom, alt name, return by reference

valid(...) from builtins.PyCapsule
valid(rosetta.core.kinematics.Edge) -> bool Is this edge valid (false for default-constructed edges)

class FoldTree(builtins.object)

    The FoldTree is a residue-based tree-like 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 Common Methods:     FoldTree.check_fold_tree     FoldTree.clear     FoldTree.new_jump     FoldTree.nres     FoldTree.num_jump     FoldTree.simple_tree     Foldtree.size

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.kinematics.FoldTree) -> NoneType 2. __init__(self : rosetta.core.kinematics.FoldTree, nres_in : int) -> NoneType 3. __init__(self : rosetta.core.kinematics.FoldTree,  : rosetta.core.kinematics.FoldTree) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

__str__(...) from builtins.PyCapsule
__str__(rosetta.core.kinematics.FoldTree) -> str

add_edge(...) from builtins.PyCapsule
add_edge(*args, **kwargs) Overloaded function. 1. add_edge(self : rosetta.core.kinematics.FoldTree, start : int, stop : int, label : int) -> NoneType Adds an edge from  <start>  to  <stop> 2. add_edge(self : rosetta.core.kinematics.FoldTree, start : int, stop : int, start_atom : str, stop_atom : str) -> NoneType Especially useful version of add_edge for chemical edge construction 3. add_edge(self : rosetta.core.kinematics.FoldTree, new_edge : rosetta.core.kinematics.Edge) -> NoneType Add the edge  <new_edge> example(s):      ft.add_edge(edge1) See also:      FoldTree      FoldTree.check_fold_tree      FoldTree.delete_edge      FoldTree.jump_edge      FoldTree.nres      FoldTree.num_jump

append_residue(...) from builtins.PyCapsule
append_residue(*args, **kwargs) Overloaded function. 1. append_residue(rosetta.core.kinematics.FoldTree) -> NoneType Appends a new residue to the tree, either by a jump or as a continuation of a peptide segment 2. append_residue(self : rosetta.core.kinematics.FoldTree, attach_by_jump : bool) -> NoneType Appends a new residue to the tree, either by a jump or as a continuation of a peptide segment 3. append_residue(self : rosetta.core.kinematics.FoldTree, attach_by_jump : bool, jump_anchor_residue : int) -> NoneType Appends a new residue to the tree, either by a jump or as a continuation of a peptide segment 4. append_residue(self : rosetta.core.kinematics.FoldTree, attach_by_jump : bool, jump_anchor_residue : int, jump_upstream_atom : str) -> NoneType Appends a new residue to the tree, either by a jump or as a continuation of a peptide segment 5. append_residue(self : rosetta.core.kinematics.FoldTree, attach_by_jump : bool, jump_anchor_residue : int, jump_upstream_atom : str, jump_downstream_atom : str) -> NoneType Appends a new residue to the tree, either by a jump or as a continuation of a peptide segment

append_residue_by_chemical_bond(...) from builtins.PyCapsule
append_residue_by_chemical_bond(self : rosetta.core.kinematics.FoldTree, anchor_residue : int, anchor_atom : str, root_atom : str) -> NoneType Appends a new residue to the tree using a chemical (APL-style) connection

apply_sequence_mapping(...) from builtins.PyCapsule
apply_sequence_mapping(self : rosetta.core.kinematics.FoldTree, old2new : rosetta.core.id.SequenceMapping) -> NoneType Renumber all vertices according to an input sequence mapping

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.FoldTree, src : rosetta.core.kinematics.FoldTree) -> rosetta.core.kinematics.FoldTree operator= this version doesn't copy any of the derived data! will this be too slow? it will trigger re-calculating of everything every time we reject a move....

begin(...) from builtins.PyCapsule
begin(rosetta.core.kinematics.FoldTree) -> __gnu_cxx::__normal_iterator<core::kinematics::Edge const*, std::vector<core::kinematics::Edge, std::allocator<core::kinematics::Edge> > > begin iterator of the edge_list

boundary_left(...) from builtins.PyCapsule
boundary_left(self : rosetta.core.kinematics.FoldTree, res : int) -> int Return the starting residue of the first kinematic Edge to which res belongs.

boundary_right(...) from builtins.PyCapsule
boundary_right(self : rosetta.core.kinematics.FoldTree, res : int) -> int Return the ending residue of the first kinematic Edge to which res belongs.

check_edges_for_atom_info(...) from builtins.PyCapsule
check_edges_for_atom_info(rosetta.core.kinematics.FoldTree) -> bool chemical edges should have atom info

check_fold_tree(...) from builtins.PyCapsule
check_fold_tree(rosetta.core.kinematics.FoldTree) -> 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

clear(...) from builtins.PyCapsule
clear(rosetta.core.kinematics.FoldTree) -> NoneType 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

clone(...) from builtins.PyCapsule
clone(rosetta.core.kinematics.FoldTree) -> rosetta.core.kinematics.FoldTree

connected(...) from builtins.PyCapsule
connected(rosetta.core.kinematics.FoldTree) -> bool Returns true if the FoldTree is connected

count_fixed_residues(...) from builtins.PyCapsule
count_fixed_residues(self : rosetta.core.kinematics.FoldTree, begin_res : int, size : int, min_edge_count_out : int) -> int

cutpoint(...) from builtins.PyCapsule
cutpoint(self : rosetta.core.kinematics.FoldTree, cut : int) -> int Returns the cutpoint position of jump number  <cut> example(s):      ft.cutpoint(1) See also:      FoldTree      FoldTree.jump_edge      FoldTree.is_cutpoint      FoldTree.is_jump_point      FoldTree.num_cutpoint      FoldTree.num_jump

cutpoint_by_jump(...) from builtins.PyCapsule
cutpoint_by_jump(self : rosetta.core.kinematics.FoldTree, jump_number : int) -> int Returns the corresponding cutpoint position for jump  <jump_number> WARNING: if you look for all cutpoints by cycling thru jump_numbers you may be dissapointed you will get most likely the same cutpoint for several different jump_numbers however: the method cutpoint( nr ) will give you the number you are looking for

cutpoint_map(...) from builtins.PyCapsule
cutpoint_map(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> int cutpoint number for this residue

cutpoints(...) from builtins.PyCapsule
cutpoints(rosetta.core.kinematics.FoldTree) -> rosetta.utility.vector1_int get all cutpoints

delete_edge(...) from builtins.PyCapsule
delete_edge(*args, **kwargs) Overloaded function. 1. delete_edge(self : rosetta.core.kinematics.FoldTree, edge : __gnu_cxx::__normal_iterator<core::kinematics::Edge*, std::vector<core::kinematics::Edge, std::allocator<core::kinematics::Edge> > >) -> NoneType Deletes the edge  <edge>  in the FoldTree by iterator 2. delete_edge(self : rosetta.core.kinematics.FoldTree, edge : rosetta.core.kinematics.Edge) -> NoneType Delete the edge  <edge>  in the fold tree by example edge example(s):      ft.delete_edge(edge1) See also:      FoldTree      FoldTree.add_edge      FoldTree.check_fold_tree      FoldTree.jump_edge      FoldTree.nres      FoldTree.num_jump

delete_extra_vertices(...) from builtins.PyCapsule
delete_extra_vertices(rosetta.core.kinematics.FoldTree) -> NoneType Delete vertices that are no longer necessary any more How is this determined?

delete_jump_and_intervening_cutpoint(...) from builtins.PyCapsule
delete_jump_and_intervening_cutpoint(*args, **kwargs) Overloaded function. 1. delete_jump_and_intervening_cutpoint(self : rosetta.core.kinematics.FoldTree, jump_begin : int, jump_end : int) -> NoneType Useful for removing a loop modeling jump+cut 2. delete_jump_and_intervening_cutpoint(self : rosetta.core.kinematics.FoldTree, jump_number : int) -> NoneType Useful for removing a loop modeling jump+cut

delete_segment(...) from builtins.PyCapsule
delete_segment(self : rosetta.core.kinematics.FoldTree, seg_begin : int, seg_end : int) -> NoneType Deletes a continuous segment from  <seq_begin>  to  <seq_end> example(s):      ft.delete_segment(13,37) See also:      FoldTree      FoldTree.check_fold_tree      FoldTree.delete_edge      FoldTree.new_jump      FoldTree.nres      FoldTree.simple_tree

delete_self_edges(...) from builtins.PyCapsule
delete_self_edges(rosetta.core.kinematics.FoldTree) -> NoneType Deletes edges with start==stop allowable 1->1 edge for single residue FoldTree

delete_seqpos(...) from builtins.PyCapsule
delete_seqpos(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> NoneType Deletes the residue  <seqpos>  from the FoldTree. Will rearrange topology if necessary. example(s):      ft.delete_seqpos(3) See also:      FoldTree      FoldTree.check_fold_tree      FoldTree.clear      FoldTree.new_jump      FoldTree.nres      FoldTree.num_jump      FoldTree.simple_tree

delete_unordered_edge(...) from builtins.PyCapsule
delete_unordered_edge(self : rosetta.core.kinematics.FoldTree, start : int, stop : int, label : int) -> NoneType Find an edge in fold tree and delete it

downstream_atom(...) from builtins.PyCapsule
downstream_atom(self : rosetta.core.kinematics.FoldTree, jump_number : int) -> str the jump atom on the stopping side

downstream_jump_residue(...) from builtins.PyCapsule
downstream_jump_residue(self : rosetta.core.kinematics.FoldTree, jump_number : int) -> int the stopping residue for this jump

edge_label(...) from builtins.PyCapsule
edge_label(self : rosetta.core.kinematics.FoldTree, start : int, stop : int) -> int Returns the edge label of the edge from  <start>  to  <stop>

empty(...) from builtins.PyCapsule
empty(rosetta.core.kinematics.FoldTree) -> 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

end(...) from builtins.PyCapsule
end(rosetta.core.kinematics.FoldTree) -> __gnu_cxx::__normal_iterator<core::kinematics::Edge const*, std::vector<core::kinematics::Edge, std::allocator<core::kinematics::Edge> > > end iterator of the edge_list

get_chemical_edges(...) from builtins.PyCapsule
get_chemical_edges(rosetta.core.kinematics.FoldTree) -> rosetta.utility.vector1_core_kinematics_Edge Returns all chemical edges from fold tree

get_jump_edges(...) from builtins.PyCapsule
get_jump_edges(rosetta.core.kinematics.FoldTree) -> rosetta.utility.vector1_core_kinematics_Edge Return all jump Edges from the FoldTree

get_jump_that_builds_residue(...) from builtins.PyCapsule
get_jump_that_builds_residue(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> int Get the number of the jump that builds (connects to) a given residue

get_outgoing_edges(...) from builtins.PyCapsule
get_outgoing_edges(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> rosetta.utility.vector1_core_kinematics_Edge Returns all edges that build a residue directly off of  <seqpos>

get_parent_residue(...) from builtins.PyCapsule
get_parent_residue(*args, **kwargs) Overloaded function. 1. get_parent_residue(self : rosetta.core.kinematics.FoldTree, seqpos : int, connected_by_jump : bool) -> int Get the residue that is immediately upstream of this residue (and tell us whether connection is jump or bond). 2. get_parent_residue(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> int Get the residue that is immediately upstream of this residue.

get_polymer_residue_direction(...) from builtins.PyCapsule
get_polymer_residue_direction(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> int Returns the direction (n2c, c2n) in which the given (peptide) residue is built during folding.

get_residue_edge(...) from builtins.PyCapsule
get_residue_edge(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> rosetta.core.kinematics.Edge Returns the edge that builds the residue  <seqpos> Does not work for root atom (will fail)

hash_value(...) from builtins.PyCapsule
hash_value(rosetta.core.kinematics.FoldTree) -> int computes a fixed-length, hash-based identifier for this FoldTree, permitting efficient comparison between a pair of FoldTrees

insert_fold_tree_by_jump(...) from builtins.PyCapsule
insert_fold_tree_by_jump(*args, **kwargs) Overloaded function. 1. insert_fold_tree_by_jump(self : rosetta.core.kinematics.FoldTree, subtree : rosetta.core.kinematics.FoldTree, insert_seqpos : int, insert_jumppos : int, anchor_pos : int) -> NoneType Inserts a fold_tree as a subtree 2. insert_fold_tree_by_jump(self : rosetta.core.kinematics.FoldTree, subtree : rosetta.core.kinematics.FoldTree, insert_seqpos : int, insert_jumppos : int, anchor_pos : int, anchor_jump_number : int) -> NoneType Inserts a fold_tree as a subtree 3. insert_fold_tree_by_jump(self : rosetta.core.kinematics.FoldTree, subtree : rosetta.core.kinematics.FoldTree, insert_seqpos : int, insert_jumppos : int, anchor_pos : int, anchor_jump_number : int, anchor_atom : str) -> NoneType Inserts a fold_tree as a subtree 4. insert_fold_tree_by_jump(self : rosetta.core.kinematics.FoldTree, subtree : rosetta.core.kinematics.FoldTree, insert_seqpos : int, insert_jumppos : int, anchor_pos : int, anchor_jump_number : int, anchor_atom : str, root_atom : str) -> NoneType Inserts a fold_tree as a subtree

insert_polymer_residue(...) from builtins.PyCapsule
insert_polymer_residue(self : rosetta.core.kinematics.FoldTree, seqpos : int, join_lower : bool, join_upper : bool) -> NoneType Inserts a polymer residue at position  <seqpos> How?

insert_residue_by_chemical_bond(...) from builtins.PyCapsule
insert_residue_by_chemical_bond(self : rosetta.core.kinematics.FoldTree, seqpos : int, anchor_residue : int, anchor_atom : str, root_atom : str) -> NoneType Inserts a bonded residue at position  <seqpos>

insert_residue_by_jump(...) from builtins.PyCapsule
insert_residue_by_jump(*args, **kwargs) Overloaded function. 1. insert_residue_by_jump(self : rosetta.core.kinematics.FoldTree, seqpos : int, anchor_pos : int) -> NoneType 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) 2. insert_residue_by_jump(self : rosetta.core.kinematics.FoldTree, seqpos : int, anchor_pos : int, anchor_atom : str) -> NoneType 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) 3. insert_residue_by_jump(self : rosetta.core.kinematics.FoldTree, seqpos : int, anchor_pos : int, anchor_atom : str, root_atomno : str) -> NoneType 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)

is_cutpoint(...) from builtins.PyCapsule
is_cutpoint(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> bool Returns true is position  <seqpos>  is a cutpoint example(s):      ft.is_cutpoint(37) See also:      FoldTree      FoldTree.cutpoint      FoldTree.new_jump      FoldTree.nres      FoldTree.num_cutpoint      FoldTree.num_jump

is_jump_point(...) from builtins.PyCapsule
is_jump_point(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> bool Returns true if  <seqpos>  is a starting or stopping residue of a jump edge example(s):      ft.is_jump_point() See also:      FoldTree      FoldTree.is_cutpoint      FoldTree.new_jump      FoldTree.num_jump

is_root(...) from builtins.PyCapsule
is_root(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> bool Returns true if  <seqpos>  the the root example(s):      ft.empty() See also:      FoldTree      FoldTree.is_cutpoint      FoldTree.is_jump_point      FoldTree.nres

is_simple_tree(...) from builtins.PyCapsule
is_simple_tree(rosetta.core.kinematics.FoldTree) -> 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

jump_edge(...) from builtins.PyCapsule
jump_edge(*args, **kwargs) Overloaded function. 1. jump_edge(self : rosetta.core.kinematics.FoldTree, jump_number : int) -> rosetta.core.kinematics.Edge Returns the jump edge with jump number  <jump_number>  (const) example(s):      ft.jump_edge(1) See also:      FoldTree      FoldTree.new_jump      FoldTree.num_jump 2. jump_edge(self : rosetta.core.kinematics.FoldTree, jump_number : int) -> rosetta.core.kinematics.Edge Returns the jump edge with jump number  <jump_number>  (non-const)

jump_exists(...) from builtins.PyCapsule
jump_exists(self : rosetta.core.kinematics.FoldTree, pos1 : int, pos2 : int) -> bool Return true if a jump exists between  <pos1>  and  <pos2> example(s):      ft.empty() See also:      FoldTree      FoldTree.check_fold_tree      FoldTree.jump_edge      FoldTree.new_jump      FoldTree.nres

jump_nr(...) from builtins.PyCapsule
jump_nr(self : rosetta.core.kinematics.FoldTree, upstream_res : int, downstream_res : int) -> int get the jump_nr connected to jump upstream->downstream, returns 0 if not found

jump_point(...) from builtins.PyCapsule
jump_point(self : rosetta.core.kinematics.FoldTree, lower_higher : int, jump_number : int) -> int starting or stopping residue of a jump edge

new_chemical_bond(...) from builtins.PyCapsule
new_chemical_bond(self : rosetta.core.kinematics.FoldTree, anchor_pos : int, root_pos : int, anchor_atom : str, root_atom : str, new_cutpoint : int) -> NoneType

new_jump(...) from builtins.PyCapsule
new_jump(self : rosetta.core.kinematics.FoldTree, jump_pos1 : int, jump_pos2 : int, cutpoint : int) -> int Adds a new jump edge from  <pos1>  to  <pos2>  with cutpoint  <cutpoint>

nres(...) from builtins.PyCapsule
nres(rosetta.core.kinematics.FoldTree) -> int Returns the number of residues in the FoldTree example(s):      ft.nres() See also:      FoldTree      FoldTree.check_fold_tree      FoldTree.num_jump      FoldTree.simple_tree      FoldTree.size

num_cutpoint(...) from builtins.PyCapsule
num_cutpoint(rosetta.core.kinematics.FoldTree) -> int Returns the number of cutpoints in the FoldTree example(s):      ft.num_cutpoint() See also:      FoldTree      FoldTree.cutpoint      FoldTree.is_cutpoint      FoldTree.nres      FoldTree.num_jump

num_jump(...) from builtins.PyCapsule
num_jump(rosetta.core.kinematics.FoldTree) -> int Returns the number of jumps in the FoldTree example(s):      ft.num_jump() See also:      FoldTree      FoldTree.check_fold_tree      FoldTree.jump_edge      FoldTree.new_jump      FoldTree.nres

partition_by_jump(...) from builtins.PyCapsule
partition_by_jump(*args, **kwargs) Overloaded function. 1. partition_by_jump(self : rosetta.core.kinematics.FoldTree, jump_number : int, f1 : rosetta.core.kinematics.FoldTree, f2 : rosetta.core.kinematics.FoldTree) -> NoneType partition into two foldtrees by cutting at jump= jump_number 2. partition_by_jump(self : rosetta.core.kinematics.FoldTree, jump_number : int, partner1 : ObjexxFCL::FArray1D<bool>) -> NoneType partition the fold tree in two parts if the jump is disconnected. 3. partition_by_jump(self : rosetta.core.kinematics.FoldTree, jump_nr : int) -> rosetta.utility.vector1_bool partition the fold tree in two parts if the jump is disconnected.

partition_by_residue(...) from builtins.PyCapsule
partition_by_residue(self : rosetta.core.kinematics.FoldTree, seqpos : int, partner1 : ObjexxFCL::FArray1D<bool>) -> NoneType partition the fold tree in two parts if a cut would be introduced between seqpos and seqpos+1

partition_coloring(...) from builtins.PyCapsule
partition_coloring(self : rosetta.core.kinematics.FoldTree, jump_numbers : rosetta.utility.vector1_unsigned_long) -> rosetta.utility.vector1_unsigned_long partition the fold tree into n parts based on specified jumps.

possible_root(...) from builtins.PyCapsule
possible_root(self : rosetta.core.kinematics.FoldTree, seqpos : int) -> bool Returns true if  <seqpos>  is the root

prepend_edge(...) from builtins.PyCapsule
prepend_edge(self : rosetta.core.kinematics.FoldTree, new_edge : rosetta.core.kinematics.Edge) -> NoneType Prepend the edge  <new_edge>. Useful alternative to add_edge for setting root.

put_jump_stubs_intra_residue(...) from builtins.PyCapsule
put_jump_stubs_intra_residue(rosetta.core.kinematics.FoldTree) -> NoneType this reorganizes upstream/downstream atoms of all jumps such that stubs are N-CA-C

random_tree_from_jump_points(...) from builtins.PyCapsule
random_tree_from_jump_points(*args, **kwargs) Overloaded function. 1. random_tree_from_jump_points(self : rosetta.core.kinematics.FoldTree, nres_in : int, num_jump_in : int, jump_point : ObjexxFCL::FArray2D<int>, cut_bias : ObjexxFCL::FArray1D<float>) -> bool Builds a FoldTree from a list of  <jump_points>  and random cut points based on some biased probability Returns bool about success 2. random_tree_from_jump_points(self : rosetta.core.kinematics.FoldTree, nres_in : int, num_jump_in : int, jump_point : ObjexxFCL::FArray2D<int>, cut_bias : ObjexxFCL::FArray1D<float>, root_in : int) -> bool Builds a FoldTree from a list of  <jump_points>  and random cut points based on some biased probability Returns bool about success 3. random_tree_from_jump_points(self : rosetta.core.kinematics.FoldTree, nres_in : int, num_jump_in : int, jump_point : ObjexxFCL::FArray2D<int>, cut_bias : ObjexxFCL::FArray1D<float>, root_in : int, allow_jump_at_1_or_NRES : bool) -> bool Builds a FoldTree from a list of  <jump_points>  and random cut points based on some biased probability Returns bool about success 4. random_tree_from_jump_points(self : rosetta.core.kinematics.FoldTree, nres_in : int, num_jump_in : int, jump_point : ObjexxFCL::FArray2D<int>, obligate_cut_points : rosetta.std.vector_int, cut_bias : ObjexxFCL::FArray1D<float>) -> bool Builds a FoldTree from a list of  <jump_points>  and random cut points based on some biased probability and any user-defined obligate cutpoints Returns bool about success 5. random_tree_from_jump_points(self : rosetta.core.kinematics.FoldTree, nres_in : int, num_jump_in : int, jump_point : ObjexxFCL::FArray2D<int>, obligate_cut_points : rosetta.std.vector_int, cut_bias : ObjexxFCL::FArray1D<float>, root_in : int) -> bool Builds a FoldTree from a list of  <jump_points>  and random cut points based on some biased probability and any user-defined obligate cutpoints Returns bool about success 6. random_tree_from_jump_points(self : rosetta.core.kinematics.FoldTree, nres_in : int, num_jump_in : int, jump_point : ObjexxFCL::FArray2D<int>, obligate_cut_points : rosetta.std.vector_int, cut_bias : ObjexxFCL::FArray1D<float>, root_in : int, allow_jump_at_1_or_NRES : bool) -> bool Builds a FoldTree from a list of  <jump_points>  and random cut points based on some biased probability and any user-defined obligate cutpoints Returns bool about success

reassign_atoms_for_intra_residue_stubs(...) from builtins.PyCapsule
reassign_atoms_for_intra_residue_stubs(rosetta.core.kinematics.FoldTree) -> NoneType this reorganizes upstream/downstream atoms of jumps that have flag keep_stub_in_resiue = true such that stubs are N-CA-C

renumber_jumps(...) from builtins.PyCapsule
renumber_jumps(rosetta.core.kinematics.FoldTree) -> NoneType Renumbers the jump edges in the FoldTree How?

reorder(...) from builtins.PyCapsule
reorder(*args, **kwargs) Overloaded function. 1. reorder(self : rosetta.core.kinematics.FoldTree, start_residue : int) -> bool Reorders the FoldTree to start at residue  <start_residue> 2. reorder(self : rosetta.core.kinematics.FoldTree, start_residue : int, verbose_if_fail : bool) -> bool Reorders the FoldTree to start at residue  <start_residue>

replace_edge(...) from builtins.PyCapsule
replace_edge(self : rosetta.core.kinematics.FoldTree, old_edge : rosetta.core.kinematics.Edge, replacement_edge : rosetta.core.kinematics.Edge) -> NoneType Find and replace an Edge in the FoldTree.

root(...) from builtins.PyCapsule
root(rosetta.core.kinematics.FoldTree) -> int Returns the root vertex position of the FoldTree example(s):      ft.empty() See also:      FoldTree      FoldTree.is_root      FoldTree.clear      FoldTree.simple_tree

set_jump_atoms(...) from builtins.PyCapsule
set_jump_atoms(*args, **kwargs) Overloaded function. 1. set_jump_atoms(self : rosetta.core.kinematics.FoldTree, jump_number : int, upstream_atom : str, downstream_atom : str) -> NoneType define the specific atoms that should be connected by this jump         This information can then be used in setting up the AtomTree from the         FoldTree. Data is stored in the Edge corresponding to this Jump.         If not specified, residue-specific defaults will be used. 2. set_jump_atoms(self : rosetta.core.kinematics.FoldTree, jump_number : int, upstream_atom : str, downstream_atom : str, bKeepStubInResidue : bool) -> NoneType define the specific atoms that should be connected by this jump         This information can then be used in setting up the AtomTree from the         FoldTree. Data is stored in the Edge corresponding to this Jump.         If not specified, residue-specific defaults will be used. 3. set_jump_atoms(self : rosetta.core.kinematics.FoldTree, jump_number : int, res1 : int, atom1 : str, res2 : int, atom2 : str) -> NoneType 4. set_jump_atoms(self : rosetta.core.kinematics.FoldTree, jump_number : int, res1 : int, atom1 : str, res2 : int, atom2 : str, bKeepStubInResidue : bool) -> NoneType

simple_tree(...) from builtins.PyCapsule
simple_tree(self : rosetta.core.kinematics.FoldTree, nres_in : int) -> NoneType Produces a 1-edge FoldTree that is  <nres_in>  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

size(...) from builtins.PyCapsule
size(rosetta.core.kinematics.FoldTree) -> 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

slide_cutpoint(...) from builtins.PyCapsule
slide_cutpoint(self : rosetta.core.kinematics.FoldTree, current_cut : int, target_cut : int) -> NoneType Slide a polymer cutpoint from one location to another

slide_jump(...) from builtins.PyCapsule
slide_jump(self : rosetta.core.kinematics.FoldTree, jump_number : int, new_res1 : int, new_res2 : int) -> NoneType change an existing jump to start and end in new positions

split_existing_edge_at_residue(...) from builtins.PyCapsule
split_existing_edge_at_residue(self : rosetta.core.kinematics.FoldTree, resNo : int) -> NoneType Splits an edge into two at a specified position.

to_string(...) from builtins.PyCapsule
to_string(rosetta.core.kinematics.FoldTree) -> str easy output of string

tree_from_jumps_and_cuts(...) from builtins.PyCapsule
tree_from_jumps_and_cuts(*args, **kwargs) Overloaded function. 1. tree_from_jumps_and_cuts(self : rosetta.core.kinematics.FoldTree, nres_in : int, num_jump_in : int, jump_point : ObjexxFCL::FArray2D<int>, cuts : ObjexxFCL::FArray1D<int>) -> bool Constructs a FoldTree from listed  <jump point>  and  <cuts> Returns bool about success 2. tree_from_jumps_and_cuts(self : rosetta.core.kinematics.FoldTree, nres_in : int, num_jump_in : int, jump_point : ObjexxFCL::FArray2D<int>, cuts : ObjexxFCL::FArray1D<int>, root_in : int) -> bool Constructs a FoldTree from listed  <jump point>  and  <cuts> Returns bool about success 3. tree_from_jumps_and_cuts(self : rosetta.core.kinematics.FoldTree, nres_in : int, num_jump_in : int, jump_point : ObjexxFCL::FArray2D<int>, cuts : ObjexxFCL::FArray1D<int>, root_in : int, verbose : bool) -> bool Constructs a FoldTree from listed  <jump point>  and  <cuts> Returns bool about success

update_edge_label(...) from builtins.PyCapsule
update_edge_label(self : rosetta.core.kinematics.FoldTree, start : int, stop : int, old_label : int, new_label : int) -> NoneType Changes the label of an edge in fold tree

upstream_atom(...) from builtins.PyCapsule
upstream_atom(self : rosetta.core.kinematics.FoldTree, jump_number : int) -> str the jump atom on the staring side

upstream_jump_residue(...) from builtins.PyCapsule
upstream_jump_residue(self : rosetta.core.kinematics.FoldTree, jump_number : int) -> int the starting residue for this jump

class Jump(builtins.object)

    an object which makes rigid-body transformation with translational and rotational perturbation See

Methods defined here:

__eq__(...) from builtins.PyCapsule
__eq__(self : rosetta.core.kinematics.Jump,  : rosetta.core.kinematics.Jump) -> bool

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.kinematics.Jump) -> NoneType 2. __init__(self : rosetta.core.kinematics.Jump, src_rt : rosetta.core.kinematics.RT) -> NoneType 3. __init__(self : rosetta.core.kinematics.Jump, stub1 : rosetta.core.kinematics.Stub, stub2 : rosetta.core.kinematics.Stub) -> NoneType 4. __init__(self : rosetta.core.kinematics.Jump, src : rosetta.core.kinematics.Jump) -> NoneType

__ne__(...) from builtins.PyCapsule
__ne__(self : rosetta.core.kinematics.Jump, other : rosetta.core.kinematics.Jump) -> bool

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

__str__(...) from builtins.PyCapsule
__str__(rosetta.core.kinematics.Jump) -> str

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.Jump, src : rosetta.core.kinematics.Jump) -> rosetta.core.kinematics.Jump copy operator

fold_in_rb_deltas(...) from builtins.PyCapsule
fold_in_rb_deltas(rosetta.core.kinematics.Jump) -> NoneType transform small changes in translation and rotation into jump

from_bond_cst(...) from builtins.PyCapsule
from_bond_cst(self : rosetta.core.kinematics.Jump, atoms : rosetta.utility.vector1_numeric_xyzVector_double_t, csts : rosetta.utility.vector1_double) -> NoneType get a jump from a bond cst definition

from_stubs(...) from builtins.PyCapsule
from_stubs(self : rosetta.core.kinematics.Jump, stub1 : rosetta.core.kinematics.Stub, stub2 : rosetta.core.kinematics.Stub) -> NoneType get a jump from two stubs

gaussian_move(...) from builtins.PyCapsule
gaussian_move(self : rosetta.core.kinematics.Jump, dir : int, trans_mag : float, rot_mag : float) -> rosetta.utility.vector1_double Given the desired magnitude of the translation and rotation components, applies Gaussian perturbation to this jump. Return the move that was applied

gaussian_move_single_rb(...) from builtins.PyCapsule
gaussian_move_single_rb(self : rosetta.core.kinematics.Jump, dir : int, mag : float, rb : int) -> NoneType

get_invert_downstream(...) from builtins.PyCapsule
get_invert_downstream(rosetta.core.kinematics.Jump) -> bool

get_invert_upstream(...) from builtins.PyCapsule
get_invert_upstream(rosetta.core.kinematics.Jump) -> bool

get_rb_center(...) from builtins.PyCapsule
get_rb_center(self : rosetta.core.kinematics.Jump, dir : int) -> rosetta.numeric.xyzVector_double_t get rb_center by direction

get_rb_delta(...) from builtins.PyCapsule
get_rb_delta(*args, **kwargs) Overloaded function. 1. get_rb_delta(self : rosetta.core.kinematics.Jump, dir : int) -> rosetta.utility.vector1_double get rb_delta by direction 2. get_rb_delta(self : rosetta.core.kinematics.Jump, rb_no : int, dir : int) -> float get rb_delta by direction and rb_number

get_rotation(...) from builtins.PyCapsule
get_rotation(rosetta.core.kinematics.Jump) -> rosetta.numeric.xyzMatrix_double_t get rotation matrix

get_translation(...) from builtins.PyCapsule
get_translation(rosetta.core.kinematics.Jump) -> rosetta.numeric.xyzVector_double_t get translation vector

identity_transform(...) from builtins.PyCapsule
identity_transform(rosetta.core.kinematics.Jump) -> NoneType reset to identity matrix, 0 translation

make_jump(...) from builtins.PyCapsule
make_jump(self : rosetta.core.kinematics.Jump, stub1 : rosetta.core.kinematics.Stub, stub2 : rosetta.core.kinematics.Stub) -> NoneType make a jump from stub1 to stub2

nonzero_deltas(...) from builtins.PyCapsule
nonzero_deltas(rosetta.core.kinematics.Jump) -> bool check whether there is rb_delta not being transformed.

ortho_check(...) from builtins.PyCapsule
ortho_check(rosetta.core.kinematics.Jump) -> bool check RT's orthogonality

random_trans(...) from builtins.PyCapsule
random_trans(self : rosetta.core.kinematics.Jump, dist_in : float) -> NoneType translate along a randomly chosen vector by dist_in

reset(...) from builtins.PyCapsule
reset(rosetta.core.kinematics.Jump) -> NoneType reset RT, rb_delta and rb_center

reverse(...) from builtins.PyCapsule
reverse(rosetta.core.kinematics.Jump) -> NoneType change the direction of a jump, e.g, upstream stub becomes downstream stub now.

reversed(...) from builtins.PyCapsule
reversed(rosetta.core.kinematics.Jump) -> rosetta.core.kinematics.Jump Return a new jump that is the inverse transformation

rotation_by_axis(...) from builtins.PyCapsule
rotation_by_axis(self : rosetta.core.kinematics.Jump, stub : rosetta.core.kinematics.Stub, axis : rosetta.numeric.xyzVector_double_t, center : rosetta.numeric.xyzVector_double_t, alpha : float) -> NoneType make a rotation of alpha degrees around axix and center

rotation_by_matrix(...) from builtins.PyCapsule
rotation_by_matrix(self : rosetta.core.kinematics.Jump, stub : rosetta.core.kinematics.Stub, center : rosetta.numeric.xyzVector_double_t, matrix : rosetta.numeric.xyzMatrix_double_t) -> NoneType make a rotation "matrix" about the center "center"

rt(...) from builtins.PyCapsule
rt(rosetta.core.kinematics.Jump) -> rosetta.core.kinematics.RT return the RT modeled by this jump --> makes new Jump, calls fold_in_rb_delte and returns RT

set_invert(...) from builtins.PyCapsule
set_invert(self : rosetta.core.kinematics.Jump, upstream : bool, downstream : bool) -> NoneType

set_rb_center(...) from builtins.PyCapsule
set_rb_center(self : rosetta.core.kinematics.Jump, dir : int, stub : rosetta.core.kinematics.Stub, center : rosetta.numeric.xyzVector_double_t) -> NoneType set rb_center by direction

set_rb_delta(...) from builtins.PyCapsule
set_rb_delta(self : rosetta.core.kinematics.Jump, rb_no : int, dir : int, value : float) -> NoneType set rb_delta by direction and rb_number

set_rb_deltas(...) from builtins.PyCapsule
set_rb_deltas(self : rosetta.core.kinematics.Jump, dir : int,  : rosetta.utility.vector1_double) -> NoneType set rb_deltas by direction

set_rotation(...) from builtins.PyCapsule
set_rotation(self : rosetta.core.kinematics.Jump, R_in : rosetta.numeric.xyzMatrix_double_t) -> NoneType set rotation matrix

set_translation(...) from builtins.PyCapsule
set_translation(self : rosetta.core.kinematics.Jump, t : rosetta.numeric.xyzVector_double_t) -> NoneType set translation vector

translation_along_axis(...) from builtins.PyCapsule
translation_along_axis(self : rosetta.core.kinematics.Jump, stub : rosetta.core.kinematics.Stub, axis : rosetta.numeric.xyzVector_double_t, dist : float) -> NoneType make a translation along axis by dist

class MinimizerMapBase(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.kinematics.MinimizerMapBase) -> NoneType 2. __init__(rosetta.core.kinematics.MinimizerMapBase, rosetta.core.kinematics.MinimizerMapBase) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

add_atom(...) from builtins.PyCapsule
add_atom(self : rosetta.core.kinematics.MinimizerMapBase, atom_id : rosetta.core.id.AtomID, dof_id : rosetta.core.id.DOF_ID) -> NoneType 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.

add_torsion(...) from builtins.PyCapsule
add_torsion(self : rosetta.core.kinematics.MinimizerMapBase, new_torsion : rosetta.core.id.DOF_ID, parent : rosetta.core.id.DOF_ID) -> NoneType 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.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.MinimizerMapBase,  : rosetta.core.kinematics.MinimizerMapBase) -> rosetta.core.kinematics.MinimizerMapBase

domain_map(...) from builtins.PyCapsule
domain_map(rosetta.core.kinematics.MinimizerMapBase) -> ObjexxFCL::FArray1D<int>

class MoveMap(builtins.object)

    A class specifying DOFs to be flexible or fixed Currently there are two groups of data, one is a residue-based Torsion definition, such as BB, CHI, NU, and JUMP; the other is an atom-based DOF definition, such as bond length D, bond angle THETA, and torsion angle PHI, which are used in the AtomTree. 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, BRANCH, 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) Settings 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 the setting for BB torsion 2 of residue 4 will first check if there is any specific setting, if not, it will check if there is a setting for all BB torsions for residue 4, if not again, it will use the setting for BB torsions for all residues. Example:     movemap = MoveMap() See also:     Pose     MinMover     ShearMover     SmallMover

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.kinematics.MoveMap) -> NoneType 2. __init__(self : rosetta.core.kinematics.MoveMap,  : rosetta.core.kinematics.MoveMap) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

__str__(...) from builtins.PyCapsule
__str__(rosetta.core.kinematics.MoveMap) -> str

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.MoveMap,  : rosetta.core.kinematics.MoveMap) -> rosetta.core.kinematics.MoveMap

clear(...) from builtins.PyCapsule
clear(rosetta.core.kinematics.MoveMap) -> NoneType clear -- sets all to FALSE

clone(...) from builtins.PyCapsule
clone(rosetta.core.kinematics.MoveMap) -> rosetta.core.kinematics.MoveMap

dof_id_begin(...) from builtins.PyCapsule
dof_id_begin(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::DOF_ID const, bool> > return an iterator pointing at the first element of the DOF_ID_Map

dof_id_end(...) from builtins.PyCapsule
dof_id_end(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::DOF_ID const, bool> > return an iterator pointing just past the last element of the DOF_ID_Map

dof_type_begin(...) from builtins.PyCapsule
dof_type_begin(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::DOF_Type const, bool> > return an iterator pointing just past the last element of the DOF_TypeMap

dof_type_end(...) from builtins.PyCapsule
dof_type_end(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::DOF_Type const, bool> > return an iterator pointing at the first element of the DOF_TypeMap

find(...) from builtins.PyCapsule
find(*args, **kwargs) Overloaded function. 1. find(self : rosetta.core.kinematics.MoveMap, t : rosetta.core.id.TorsionType) -> std::_Rb_tree_const_iterator<std::pair<core::id::TorsionType const, bool> > find the explicit setting for the given TorsionType iterator pointing to the TorsionType-bool pair, otherwise   torsion_type_end() 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. 2. find(self : rosetta.core.kinematics.MoveMap, id : (int, rosetta.core.id.TorsionType)) -> std::_Rb_tree_const_iterator<std::pair<std::pair<unsigned long, core::id::TorsionType> const, bool> > find the explicit setting for the given MoveMapTorsionID iterator pointing to the MoveMapTorsionID-bool pair, otherwise   movemap_torsion_id_end() 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. 3. find(self : rosetta.core.kinematics.MoveMap, id : rosetta.core.id.TorsionID) -> std::_Rb_tree_const_iterator<std::pair<core::id::TorsionID const, bool> > find the explicit setting for the given TorsionID iterator pointing to the TorsionID-bool pair, otherwise torsion_id_end() 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. 4. find(self : rosetta.core.kinematics.MoveMap, jump : rosetta.core.id.JumpID) -> std::_Rb_tree_const_iterator<std::pair<core::id::JumpID const, bool> > find the explicit setting for the given JumpID iterator pointing to the JumpID-bool pair, otherwise jump_id_end() 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. 5. find(self : rosetta.core.kinematics.MoveMap, t : rosetta.core.id.DOF_Type) -> std::_Rb_tree_const_iterator<std::pair<core::id::DOF_Type const, bool> > find the explicit setting for the given DOF_Type iterator pointing to the DOF_Type-bool pair, otherwise dof_type_end() 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. 6. find(self : rosetta.core.kinematics.MoveMap, id : rosetta.core.id.DOF_ID) -> std::_Rb_tree_const_iterator<std::pair<core::id::DOF_ID const, bool> > find the explicit setting for the given DOF_ID iterator pointing to the DOF_ID-bool pair, otherwise dof_id_end() 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.

get(...) from builtins.PyCapsule
get(*args, **kwargs) Overloaded function. 1. get(self : rosetta.core.kinematics.MoveMap, t : rosetta.core.id.TorsionType) -> bool get setting for a specific TorsionType, such as "BB" 2. get(self : rosetta.core.kinematics.MoveMap, id : (int, rosetta.core.id.TorsionType)) -> bool get TorsionType flexible or fixed for one residue, eg BB torsions for residue 10 3. get(self : rosetta.core.kinematics.MoveMap, id : rosetta.core.id.TorsionID) -> bool 4. get(self : rosetta.core.kinematics.MoveMap, t : rosetta.core.id.DOF_Type) -> bool get the default for this type of DOF, eg "PHI" 5. get(self : rosetta.core.kinematics.MoveMap, id : rosetta.core.id.DOF_ID) -> bool get the setting for an individual dof, eg, PHI of Atom 3 in Residue 5

get_bb(...) from builtins.PyCapsule
get_bb(*args, **kwargs) Overloaded function. 1. get_bb(self : rosetta.core.kinematics.MoveMap, seqpos : int) -> bool Returns if BB torsions are movable or not for residue  <seqpos> example:      movemap.get_bb(49) 2. get_bb(self : rosetta.core.kinematics.MoveMap, seqpos : int, torsion_id : int) -> bool Returns if a specific BB torsion is movable or not for residue  <seqpos> example:      movemap.get_bb(49)

get_branches(...) from builtins.PyCapsule
get_branches(self : rosetta.core.kinematics.MoveMap, seqpos : int) -> bool Return if BRANCH torsions are movable or not for residue <seqpos>. : Example: movemap.get_branches(49)

get_chi(...) from builtins.PyCapsule
get_chi(self : rosetta.core.kinematics.MoveMap, seqpos : int) -> bool Returns if SC torsions are movable or not for residue  <seqpos> example:      movemap.get_chi(49)

get_jump(...) from builtins.PyCapsule
get_jump(*args, **kwargs) Overloaded function. 1. get_jump(self : rosetta.core.kinematics.MoveMap, jump_number : int) -> bool Returns if JUMP  <jump_number>  is movable or not example:      movemap.get_jump(1) 2. get_jump(self : rosetta.core.kinematics.MoveMap, pos1 : int, pos2 : int) -> bool 3. get_jump(self : rosetta.core.kinematics.MoveMap, jump : rosetta.core.id.JumpID) -> bool

get_nu(...) from builtins.PyCapsule
get_nu(self : rosetta.core.kinematics.MoveMap, seqpos : int) -> bool Return if NU torsions are movable or not for residue <seqpos>. : Example: movemap.get_nu(49)

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

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

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

init_from_file(...) from builtins.PyCapsule
init_from_file(self : rosetta.core.kinematics.MoveMap, filename : str) -> NoneType Read MoveMap from file.

jump_id_begin(...) from builtins.PyCapsule
jump_id_begin(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::JumpID const, bool> > return an iterator pointing at the first element of the JumpID_Map

jump_id_end(...) from builtins.PyCapsule
jump_id_end(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::JumpID const, bool> > return an iterator pointing just past the last element of the JumpID_Map

movemap_torsion_id_begin(...) from builtins.PyCapsule
movemap_torsion_id_begin(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<std::pair<unsigned long, core::id::TorsionType> const, bool> > return an iterator pointing at the first element of the MoveMapTorsionID_Map

movemap_torsion_id_end(...) from builtins.PyCapsule
movemap_torsion_id_end(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<std::pair<unsigned long, core::id::TorsionType> const, bool> > return an iterator pointing just past the last element of the MoveMapTorsionID_Map

set(...) from builtins.PyCapsule
set(*args, **kwargs) Overloaded function. 1. set(self : rosetta.core.kinematics.MoveMap, t : rosetta.core.id.TorsionType, setting : bool) -> NoneType set a specific TorsionType movable: currently BB, CHI, NU, BRANCH, or JUMP 2. set(self : rosetta.core.kinematics.MoveMap, id : (int, rosetta.core.id.TorsionType), setting : bool) -> NoneType set TorsionType flexible or fixed for one residue, e.g., BB torsions for residue 10 3. set(self : rosetta.core.kinematics.MoveMap, id : rosetta.core.id.TorsionID, setting : bool) -> NoneType set an individual Torsion movable for now, e.g., "BB torsion 2 of residue 4" 4. set(self : rosetta.core.kinematics.MoveMap, t : rosetta.core.id.DOF_Type, setting : bool) -> NoneType set atom tree DOF, e.g., D, PHI, THETA 5. set(self : rosetta.core.kinematics.MoveMap, id : rosetta.core.id.DOF_ID, setting : bool) -> NoneType set for an individual DoF, e.g., "PHI of Atom 3 in Residue 5"

set_bb(...) from builtins.PyCapsule
set_bb(*args, **kwargs) Overloaded function. 1. set_bb(self : rosetta.core.kinematics.MoveMap, setting : bool) -> NoneType Set whether or not BB TorsionType is moveable example:      movemap.set_bb(True) See also:      MoveMap      MoveMap.set_chi      MoveMap.set_nu      MoveMap.set_branches      Pose      MinMover      ShearMover      SmallMover 2. set_bb(self : rosetta.core.kinematics.MoveMap, seqpos : int, setting : bool) -> NoneType Sets whether or not the BB torsions of residue  <seqpos>  are movable example:      movemap.set_bb(49,True) See also:      MoveMap      MoveMap.set_chi      MoveMap.set_nu      MoveMap.set_branches      Pose      MinMover      ShearMover      SmallMover 3. set_bb(self : rosetta.core.kinematics.MoveMap, seqpos : int, torsion_id : int, setting : bool) -> NoneType Sets whether or not the BB torsion of residue  <seqpos> and torsion <torsion_id> are movable example:      movemap.set_bb(49, 1, True) See also:      MoveMap      MoveMap.set_chi      MoveMap.set_nu      MoveMap.set_branches      Pose      MinMover      ShearMover      SmallMover 4. set_bb(self : rosetta.core.kinematics.MoveMap, allow_bb : rosetta.utility.vector1_bool) -> NoneType Sets BB torsions movable based on input array

set_bb_true_range(...) from builtins.PyCapsule
set_bb_true_range(self : rosetta.core.kinematics.MoveMap, begin : int, end : int) -> NoneType Sets the BB torsions between residues  <begin>  and  <end> 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      MoveMap.set_branches      Pose      MinMover      ShearMover      SmallMover

set_branches(...) from builtins.PyCapsule
set_branches(*args, **kwargs) Overloaded function. 1. set_branches(self : rosetta.core.kinematics.MoveMap, setting : bool) -> NoneType Set whether or not BRANCH TorsionTypes are movable. Example: movemap.set_branches( True ) See also:      MoveMap      MoveMap.set_bb      MoveMap.set_chi      MoveMap.set_nu      Pose      MinMover      ShearMover      SmallMover 2. set_branches(self : rosetta.core.kinematics.MoveMap, seqpos : int, setting : bool) -> NoneType Set whether or not the BRANCH torsions of residue <seqpos> are movable. Example: movemap.set_branches(49, True) See also:      MoveMap      MoveMap.set_bb      MoveMap.set_chi      MoveMap.set_nu      Pose      MinMover      ShearMover      SmallMover 3. set_branches(self : rosetta.core.kinematics.MoveMap, settings : rosetta.utility.vector1_bool) -> NoneType Set which BRANCH torsions are movable based on input array.

set_branches_true_range(...) from builtins.PyCapsule
set_branches_true_range(self : rosetta.core.kinematics.MoveMap, begin : int, end : int) -> NoneType Set the BRANCH torsions between residues <begin> and <end> as movable and all other residues are non-movable. Example: movemap.set_branches_true_range(40, 60) See also:      MoveMap      MoveMap.set_bb      MoveMap.set_bb_true_range      MoveMap.set_chi      MoveMap.set_chi_true_range      MoveMap.set_nu      MoveMap.set_nu_true_range      MoveMap.set_branches      Pose      MinMover      ShearMover      SmallMover

set_chi(...) from builtins.PyCapsule
set_chi(*args, **kwargs) Overloaded function. 1. set_chi(self : rosetta.core.kinematics.MoveMap, setting : bool) -> NoneType Sets whether or not CHI TorsionType is movable example:      movemap.set_chi(True) See also:      MoveMap      MoveMap.set_bb      MoveMap.set_nu      MoveMap.set_branches      Pose      MinMover      ShearMover      SmallMover 2. set_chi(self : rosetta.core.kinematics.MoveMap, seqpos : int, setting : bool) -> NoneType Sets whether or not the CHI torsions of residue  <seqpos>  are movable example:      movemap.set_chi(49,True) See also:      MoveMap      MoveMap.set_bb      MoveMap.set_nu      MoveMap.set_branches      Pose      MinMover      ShearMover      SmallMover inline 3. set_chi(self : rosetta.core.kinematics.MoveMap, allow_chi : rosetta.utility.vector1_bool) -> NoneType set CHI torsions movable based on input array

set_chi_true_range(...) from builtins.PyCapsule
set_chi_true_range(self : rosetta.core.kinematics.MoveMap, begin : int, end : int) -> NoneType Sets the chi torsions between residues <begin> and <end> 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      MoveMap.set_branches      MoveMap.set_branches_true_range      Pose      MinMover      ShearMover      SmallMover

set_jump(...) from builtins.PyCapsule
set_jump(*args, **kwargs) Overloaded function. 1. set_jump(self : rosetta.core.kinematics.MoveMap, setting : bool) -> NoneType Sets whether or not JUMP TorsionType is moveable example:      movemap.set_jump(True) 2. set_jump(self : rosetta.core.kinematics.MoveMap, jump_number : int, setting : bool) -> NoneType Sets the movability of JUMP  <jump_number>  to  <setting> example:      movemap.set_jump(1,True) 3. set_jump(self : rosetta.core.kinematics.MoveMap, pos1 : int, pos2 : int, setting : bool) -> NoneType 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 4. set_jump(self : rosetta.core.kinematics.MoveMap, jump : rosetta.core.id.JumpID, setting : bool) -> NoneType

set_nu(...) from builtins.PyCapsule
set_nu(*args, **kwargs) Overloaded function. 1. set_nu(self : rosetta.core.kinematics.MoveMap, setting : bool) -> NoneType Set whether or not NU TorsionTypes are movable. Example: movemap.set_nu(True) See also:      MoveMap      MoveMap.set_bb      MoveMap.set_chi      MoveMap.set_branches      Pose      MinMover      ShearMover      SmallMover 2. set_nu(self : rosetta.core.kinematics.MoveMap, seqpos : int, setting : bool) -> NoneType Set whether or not the NU torsions of residue <seqpos> are movable. Example: movemap.set_nu(49, True) See also:      MoveMap      MoveMap.set_bb      MoveMap.set_chi      MoveMap.set_branches      Pose      MinMover      ShearMover      SmallMover

set_nu_true_range(...) from builtins.PyCapsule
set_nu_true_range(self : rosetta.core.kinematics.MoveMap, begin : int, end : int) -> NoneType Set the NU torsions between residues <begin> and <end> as movable and all other residues are non-movable. Example: movemap.set_nu_true_range(40, 60) See also:      MoveMap      MoveMap.set_bb      MoveMap.set_bb_true_range      MoveMap.set_chi      MoveMap.set_chi_true_range      MoveMap.set_nu      MoveMap.set_branches      MoveMap.set_branches_true_range      Pose      MinMover      ShearMover      SmallMover

set_nus(...) from builtins.PyCapsule
set_nus(self : rosetta.core.kinematics.MoveMap, settings : rosetta.utility.vector1_bool) -> NoneType Set which NU torsions are movable based on input array.

set_ranges_unmodifiable(...) from builtins.PyCapsule
set_ranges_unmodifiable(self : rosetta.core.kinematics.MoveMap, ranges : rosetta.std.vector_std_pair_unsigned_long_unsigned_long_t) -> NoneType Prevents backbone torsion modifications to the intervals specified by <ranges>. Each element of the vector is a pair, which specifies the begin and end indices. Counting begins with 1.

show(...) from builtins.PyCapsule
show(*args, **kwargs) Overloaded function. 1. show(self : rosetta.core.kinematics.MoveMap, i : int) -> NoneType Give the TorsionType bool values up to a given residue number. wrapper for PyRosetta 2. show(rosetta.core.kinematics.MoveMap) -> NoneType

torsion_id_begin(...) from builtins.PyCapsule
torsion_id_begin(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::TorsionID const, bool> > return an iterator pointing at the first element of the TorsionID_Map

torsion_id_end(...) from builtins.PyCapsule
torsion_id_end(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::TorsionID const, bool> > return an iterator pointing just past the last element of the TorsionID_Map

torsion_type_begin(...) from builtins.PyCapsule
torsion_type_begin(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::TorsionType const, bool> > return an iterator pointing just past the last element of the TorsionTypeMap

torsion_type_end(...) from builtins.PyCapsule
torsion_type_end(rosetta.core.kinematics.MoveMap) -> std::_Rb_tree_const_iterator<std::pair<core::id::TorsionType const, bool> > return an iterator pointing at the first element of the TorsionTypeMap

class RT(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.kinematics.RT) -> NoneType 2. __init__(self : rosetta.core.kinematics.RT, rot : rosetta.numeric.xyzMatrix_double_t, vec : rosetta.numeric.xyzVector_double_t) -> NoneType 3. __init__(self : rosetta.core.kinematics.RT, stub1 : rosetta.core.kinematics.Stub, stub2 : rosetta.core.kinematics.Stub) -> NoneType 4. __init__(self : rosetta.core.kinematics.RT, src : rosetta.core.kinematics.RT) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

__str__(...) from builtins.PyCapsule
__str__(rosetta.core.kinematics.RT) -> str

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.RT, src : rosetta.core.kinematics.RT) -> rosetta.core.kinematics.RT copy operator

distance_squared(...) from builtins.PyCapsule
distance_squared(self : rosetta.core.kinematics.RT, b : rosetta.core.kinematics.RT) -> float

fold_in_rb_deltas(...) from builtins.PyCapsule
fold_in_rb_deltas(self : rosetta.core.kinematics.RT, rb : rosetta.utility.vector1_double, rb_center : rosetta.numeric.xyzVector_double_t) -> NoneType 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

from_stubs(...) from builtins.PyCapsule
from_stubs(self : rosetta.core.kinematics.RT, stub1 : rosetta.core.kinematics.Stub, stub2 : rosetta.core.kinematics.Stub) -> NoneType update from stubs

get_rotation(...) from builtins.PyCapsule
get_rotation(rosetta.core.kinematics.RT) -> rosetta.numeric.xyzMatrix_double_t get the rotation

get_translation(...) from builtins.PyCapsule
get_translation(rosetta.core.kinematics.RT) -> rosetta.numeric.xyzVector_double_t get the translation

identity_transform(...) from builtins.PyCapsule
identity_transform(rosetta.core.kinematics.RT) -> NoneType return to default-constructed state (another name)

inverse(...) from builtins.PyCapsule
inverse(rosetta.core.kinematics.RT) -> NoneType reverse the "view"

make_jump(...) from builtins.PyCapsule
make_jump(self : rosetta.core.kinematics.RT, stub1 : rosetta.core.kinematics.Stub, stub2 : rosetta.core.kinematics.Stub) -> NoneType should be inverse of RT::from_stubs

ortho_check(...) from builtins.PyCapsule
ortho_check(rosetta.core.kinematics.RT) -> bool check for orthogonality

reset(...) from builtins.PyCapsule
reset(rosetta.core.kinematics.RT) -> NoneType return to default-constructed state

reverse(...) from builtins.PyCapsule
reverse(rosetta.core.kinematics.RT) -> NoneType reverse the "view"

set_rotation(...) from builtins.PyCapsule
set_rotation(self : rosetta.core.kinematics.RT, r : rosetta.numeric.xyzMatrix_double_t) -> NoneType set the rotation

set_translation(...) from builtins.PyCapsule
set_translation(self : rosetta.core.kinematics.RT, t : rosetta.numeric.xyzVector_double_t) -> NoneType set the tranlsation

class ResidueCoordinateChangeList(builtins.object)

    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.

Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(rosetta.core.kinematics.ResidueCoordinateChangeList) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.ResidueCoordinateChangeList, rhs : rosetta.core.kinematics.ResidueCoordinateChangeList) -> rosetta.core.kinematics.ResidueCoordinateChangeList

clear(...) from builtins.PyCapsule
clear(rosetta.core.kinematics.ResidueCoordinateChangeList) -> NoneType Reset the list of those residues that have moved.  O(k).

empty(...) from builtins.PyCapsule
empty(rosetta.core.kinematics.ResidueCoordinateChangeList) -> bool Is the list of the changed residues empty?

mark_residue_moved(...) from builtins.PyCapsule
mark_residue_moved(*args, **kwargs) Overloaded function. 1. mark_residue_moved(self : rosetta.core.kinematics.ResidueCoordinateChangeList, atid : rosetta.core.id.AtomID) -> NoneType Mark a residue as having changed by passing in an AtomId for one atom in that residue 2. mark_residue_moved(self : rosetta.core.kinematics.ResidueCoordinateChangeList, resid : int) -> NoneType Mark a residue as having changed by passing in the index of that residue.

residues_moved_begin(...) from builtins.PyCapsule
residues_moved_begin(rosetta.core.kinematics.ResidueCoordinateChangeList) -> __gnu_cxx::__normal_iterator<unsigned long const*, std::vector<unsigned long, std::allocator<unsigned long> > > returns an iterator to the beginning of the (unordered) list of residues that have moved.

residues_moved_end(...) from builtins.PyCapsule
residues_moved_end(rosetta.core.kinematics.ResidueCoordinateChangeList) -> __gnu_cxx::__normal_iterator<unsigned long const*, std::vector<unsigned long, std::allocator<unsigned long> > > returns an iterator to the end of the (unordered) list of residues that have moved.

total_residue(...) from builtins.PyCapsule
total_residue(*args, **kwargs) Overloaded function. 1. total_residue(self : rosetta.core.kinematics.ResidueCoordinateChangeList, total_residue : int) -> NoneType Set the number of residues in the conformation being tracked. 2. total_residue(rosetta.core.kinematics.ResidueCoordinateChangeList) -> int Return the number of

class ShortestPathInFoldTree(builtins.object)

    Methods defined here:

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(self : rosetta.core.kinematics.ShortestPathInFoldTree, f : rosetta.core.kinematics.FoldTree) -> NoneType 2. __init__(self : rosetta.core.kinematics.ShortestPathInFoldTree, src : rosetta.core.kinematics.ShortestPathInFoldTree) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.ShortestPathInFoldTree,  : rosetta.core.kinematics.ShortestPathInFoldTree) -> rosetta.core.kinematics.ShortestPathInFoldTree

dist(...) from builtins.PyCapsule
dist(self : rosetta.core.kinematics.ShortestPathInFoldTree, pos1 : int, pos2 : int) -> int returns the shortest distance of two residues going along Fold-Tree edges.

max_dist(...) from builtins.PyCapsule
max_dist(rosetta.core.kinematics.ShortestPathInFoldTree) -> int returns the shortest distance for the two residues that are furthest apart

class Stub(builtins.object)

    ////////////////////////////////////////////////////////////////////////// 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

Methods defined here:

__eq__(...) from builtins.PyCapsule
__eq__(self : rosetta.core.kinematics.Stub, rhs : rosetta.core.kinematics.Stub) -> bool

__init__(...) from builtins.PyCapsule
__init__(*args, **kwargs) Overloaded function. 1. __init__(rosetta.core.kinematics.Stub) -> NoneType 2. __init__(self : rosetta.core.kinematics.Stub, M_in : rosetta.numeric.xyzMatrix_double_t, v_in : rosetta.numeric.xyzVector_double_t) -> NoneType 3. __init__(self : rosetta.core.kinematics.Stub, rt : core::kinematics::RT) -> NoneType 4. __init__(self : rosetta.core.kinematics.Stub, center : rosetta.numeric.xyzVector_double_t, a : rosetta.numeric.xyzVector_double_t, b : rosetta.numeric.xyzVector_double_t, c : rosetta.numeric.xyzVector_double_t) -> NoneType 5. __init__(self : rosetta.core.kinematics.Stub, a : rosetta.numeric.xyzVector_double_t, b : rosetta.numeric.xyzVector_double_t, c : rosetta.numeric.xyzVector_double_t) -> NoneType 6. __init__(self : rosetta.core.kinematics.Stub,  : rosetta.core.kinematics.Stub) -> NoneType

__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

__str__(...) from builtins.PyCapsule
__str__(rosetta.core.kinematics.Stub) -> str

assign(...) from builtins.PyCapsule
assign(self : rosetta.core.kinematics.Stub,  : rosetta.core.kinematics.Stub) -> rosetta.core.kinematics.Stub

build_fake_xyz(...) from builtins.PyCapsule
build_fake_xyz(self : rosetta.core.kinematics.Stub, index : int) -> rosetta.numeric.xyzVector_double_t Build stubatom coords that would yield this stub

center(...) from builtins.PyCapsule
center(rosetta.core.kinematics.Stub) -> rosetta.numeric.xyzVector_double_t Coordinate frame center.

from_four_points(...) from builtins.PyCapsule
from_four_points(self : rosetta.core.kinematics.Stub, center : rosetta.numeric.xyzVector_double_t, a : rosetta.numeric.xyzVector_double_t, b : rosetta.numeric.xyzVector_double_t, c : rosetta.numeric.xyzVector_double_t) -> NoneType build a stub from a center and other three points a, b, c

global2local(...) from builtins.PyCapsule
global2local(self : rosetta.core.kinematics.Stub, xyz : rosetta.numeric.xyzVector_double_t) -> rosetta.numeric.xyzVector_double_t convert a global reference (lab) frame vector to our local (stub) frame

is_orthogonal(...) from builtins.PyCapsule
is_orthogonal(self : rosetta.core.kinematics.Stub, tolerance : float) -> bool check if the stub is orthogonal under the tolerance cutoff

local2global(...) from builtins.PyCapsule
local2global(self : rosetta.core.kinematics.Stub, xyz : rosetta.numeric.xyzVector_double_t) -> rosetta.numeric.xyzVector_double_t convert a local reference (stub) frame vector to the global (lab) frame

rotation(...) from builtins.PyCapsule
rotation(rosetta.core.kinematics.Stub) -> rosetta.numeric.xyzMatrix_double_t Coordinate frame rotation matrix.

spherical(...) from builtins.PyCapsule
spherical(self : rosetta.core.kinematics.Stub, phi : float, theta : float, d : float) -> rosetta.numeric.xyzVector_double_t 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

Data descriptors defined here:

M

v

Functions

add_atom(...) method of builtins.PyCapsule instance
add_atom(atomno : int, seqpos : int, links : rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t, atom_ptr : rosetta.utility.vector1_std_shared_ptr_core_kinematics_tree_Atom_t, add_jump_atom : bool) -> rosetta.core.kinematics.tree.Atom creat an atom and add it to the residue atom-tree based on information stored in links.

distance(...) method of builtins.PyCapsule instance
distance(*args, **kwargs) Overloaded function. 1. distance(a : rosetta.core.kinematics.Stub, b : rosetta.core.kinematics.Stub) -> float root squared deviation between two stubs 2. distance(a : rosetta.core.kinematics.RT, b : rosetta.core.kinematics.RT) -> float 3. distance(a_in : rosetta.core.kinematics.Jump, b_in : rosetta.core.kinematics.Jump) -> float RT root squared deviation

get_residues_from_movemap_bb_any_torsion(...) method of builtins.PyCapsule instance
get_residues_from_movemap_bb_any_torsion(movemap : rosetta.core.kinematics.MoveMap, total_resnum : int) -> rosetta.utility.vector1_unsigned_long Get a vector of residues that have any of their BB torsions on - either by way of the full bb or torsion ID setting in Movemap.

get_residues_from_movemap_with_id(...) method of builtins.PyCapsule instance
get_residues_from_movemap_with_id(query_torsion : rosetta.core.id.TorsionType, movemap : rosetta.core.kinematics.MoveMap) -> rosetta.utility.vector1_unsigned_long Get a vector of residues matching the id from a movemap.

jump_distance(...) method of builtins.PyCapsule instance
jump_distance(a_in : rosetta.core.kinematics.Jump, b_in : rosetta.core.kinematics.Jump, dist : float, theta : float) -> NoneType compare the difference of two jumps in term of the translation (dist) and rotational angle(theta)

linearize_fold_tree(...) method of builtins.PyCapsule instance
linearize_fold_tree(tree : rosetta.core.kinematics.FoldTree) -> rosetta.core.kinematics.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

pick_loopy_cutpoint(...) method of builtins.PyCapsule instance
pick_loopy_cutpoint(n_res : int, cut_bias_sum : ObjexxFCL::FArray1D<float>) -> int

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

setup_backrub_atom_tree(...) method of builtins.PyCapsule instance
setup_backrub_atom_tree(mainchain : rosetta.utility.vector1_core_id_AtomID, downstream_id : rosetta.core.id.AtomID, old_atom_pointer : rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t, edges : rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t, first_new_pseudo_residue : int) -> rosetta.core.kinematics.tree.Atom

visualize_fold_tree(...) method of builtins.PyCapsule instance
visualize_fold_tree(*args, **kwargs) Overloaded function. 1. visualize_fold_tree(fold_tree : rosetta.core.kinematics.FoldTree) -> str sheffler 2. visualize_fold_tree(fold_tree : rosetta.core.kinematics.FoldTree, node_labels_partial : rosetta.std.map_unsigned_long_std_string) -> str 3. visualize_fold_tree(fold_tree : rosetta.core.kinematics.FoldTree, mark_jump_to_res : rosetta.std.map_unsigned_long_char) -> str 4. visualize_fold_tree(fold_tree : rosetta.core.kinematics.FoldTree, node_labels_partial : rosetta.std.map_unsigned_long_std_string, mark_jump_to_res : rosetta.std.map_unsigned_long_char, jump_follows : rosetta.std.map_unsigned_long_unsigned_long) -> str