kinematics

• inverse
• jacobian
• tree

Bindings for core::kinematics namespace

class pyrosetta.rosetta.core.kinematics.AtomTree

Bases: pybind11_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

assign(self: pyrosetta.rosetta.core.kinematics.AtomTree, src: pyrosetta.rosetta.core.kinematics.AtomTree) → pyrosetta.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.

C++: core::kinematics::AtomTree::operator=(const class core::kinematics::AtomTree &) –> class core::kinematics::AtomTree &

atom(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.AtomID) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::AtomTree::atom(const class core::id::AtomID &) const –> const class core::kinematics::tree::Atom &

atom_dont_do_update(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.AtomID) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::AtomTree::atom_dont_do_update(const class core::id::AtomID &) const –> const class core::kinematics::tree::Atom &

batch_set_xyz(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.utility.vector1_core_id_AtomID, xyz: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t) → None

simultaniously set several atom xyz positions

C++: core::kinematics::AtomTree::batch_set_xyz(const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &, const class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &) –> void

bond_angle(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1: pyrosetta.rosetta.core.id.AtomID, atom2: pyrosetta.rosetta.core.id.AtomID, atom3: pyrosetta.rosetta.core.id.AtomID) → float

C++: core::kinematics::AtomTree::bond_angle(const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &) const –> double

bond_angle_dof_id(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1_in_id: pyrosetta.rosetta.core.id.AtomID, atom2_in_id: pyrosetta.rosetta.core.id.AtomID, atom3_in_id: pyrosetta.rosetta.core.id.AtomID, offset: float) → pyrosetta.rosetta.core.id.DOF_ID

get the DOF_ID of a bond angle given those 3 atoms which define this torsion

C++: core::kinematics::AtomTree::bond_angle_dof_id(const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &, double &) const –> class core::id::DOF_ID

bond_length(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1: pyrosetta.rosetta.core.id.AtomID, atom2: pyrosetta.rosetta.core.id.AtomID) → float

C++: core::kinematics::AtomTree::bond_length(const class core::id::AtomID &, const class core::id::AtomID &) const –> double

bond_length_dof_id(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1_in_id: pyrosetta.rosetta.core.id.AtomID, atom2_in_id: pyrosetta.rosetta.core.id.AtomID) → pyrosetta.rosetta.core.id.DOF_ID

get the DOF_ID of a bond length given those 2 atoms which define this torsion

C++: core::kinematics::AtomTree::bond_length_dof_id(const class core::id::AtomID &, const class core::id::AtomID &) const –> class core::id::DOF_ID

clear(self: pyrosetta.rosetta.core.kinematics.AtomTree) → None

clear the content of an AtomTree object, delete root atom and all pointers

C++: core::kinematics::AtomTree::clear() –> void

copy_coords(self: pyrosetta.rosetta.core.kinematics.AtomTree, src: pyrosetta.rosetta.core.kinematics.AtomTree) → None

copy the internal and xyz coords from src tree, which should have the same topology as me

C++: core::kinematics::AtomTree::copy_coords(const class core::kinematics::AtomTree &) –> void

delete_seqpos(self: pyrosetta.rosetta.core.kinematics.AtomTree, seqpos: int) → None

Deletes atoms for seqpos.

Does not renumber other atoms – need to call update_sequence_numbering for that designed for the simple case of 1 incoming connecting and 0 or 1 outgoing connection, where the desired behavior is to rewire the outgoing connection in place of seqpos’ tree

C++: core::kinematics::AtomTree::delete_seqpos(const unsigned long) –> void

detached_copy(self: pyrosetta.rosetta.core.kinematics.AtomTree, src: pyrosetta.rosetta.core.kinematics.AtomTree) → None

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

C++: core::kinematics::AtomTree::detached_copy(const class core::kinematics::AtomTree &) –> void

dof(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.DOF_ID) → float

get value of DOF( PHI, THETA, D, RB1, ….) given its DOF_ID

C++: core::kinematics::AtomTree::dof(const class core::id::DOF_ID &) const –> double

empty(self: pyrosetta.rosetta.core.kinematics.AtomTree) → bool

is there any atom in the tree yet?

C++: core::kinematics::AtomTree::empty() const –> bool

get_jump_atom_id(self: pyrosetta.rosetta.core.kinematics.AtomTree, stub_id1: pyrosetta.rosetta.core.id.StubID, stub_id2: pyrosetta.rosetta.core.id.StubID, direction: int) → pyrosetta.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

C++: core::kinematics::AtomTree::get_jump_atom_id(const class core::id::StubID &, const class core::id::StubID &, int &) const –> class core::id::AtomID

get_stub_transform(self: pyrosetta.rosetta.core.kinematics.AtomTree, stub_id1: pyrosetta.rosetta.core.id.StubID, stub_id2: pyrosetta.rosetta.core.id.StubID) → pyrosetta.rosetta.core.kinematics.RT

get the transform between two stubs

C++: core::kinematics::AtomTree::get_stub_transform(const class core::id::StubID &, const class core::id::StubID &) const –> class core::kinematics::RT

has(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.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

C++: core::kinematics::AtomTree::has(const class core::id::AtomID &) const –> bool

jump(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.AtomID) → pyrosetta.rosetta.core.kinematics.Jump

C++: core::kinematics::AtomTree::jump(const class core::id::AtomID &) const –> const class core::kinematics::Jump &

note_coordinate_change_registered(self: pyrosetta.rosetta.core.kinematics.AtomTree) → None

The AtomTree provides a list of residues who’s xyz coordinates have changed

to the Conformation object. When the Conformation has finished reading off residues that have changed from the AtomTree, and has copied the coordinates of those residues into its conformation::Residue objects, it informs the AtomTree to reset this list by a call to mark_changed_residues_registered

C++: core::kinematics::AtomTree::note_coordinate_change_registered() const –> void

promote_sameresidue_nonjump_child(self: pyrosetta.rosetta.core.kinematics.AtomTree, parent_atom_id: pyrosetta.rosetta.core.id.AtomID) → None

Useful for guaranteeing that a stub remains within a single residue

C++: core::kinematics::AtomTree::promote_sameresidue_nonjump_child(const class core::id::AtomID &) –> void

replace_tree(*args, **kwargs)

Overloaded function.

1. replace_tree(self: pyrosetta.rosetta.core.kinematics.AtomTree, new_atom_pointer: pyrosetta.rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) -> None

2. replace_tree(self: pyrosetta.rosetta.core.kinematics.AtomTree, new_atom_pointer: pyrosetta.rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t, from_xyz: bool) -> None

replaces the entire tree

C++: core::kinematics::AtomTree::replace_tree(const class core::id::AtomID_Map<class std::shared_ptr<class core::kinematics::tree::Atom> > &, const bool) –> void

root(self: pyrosetta.rosetta.core.kinematics.AtomTree) → pyrosetta.rosetta.core.kinematics.tree.Atom

const-access to the root of the tree

C++: core::kinematics::AtomTree::root() const –> class std::shared_ptr<const class core::kinematics::tree::Atom>

set_bond_angle(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1: pyrosetta.rosetta.core.id.AtomID, atom2: pyrosetta.rosetta.core.id.AtomID, atom3: pyrosetta.rosetta.core.id.AtomID, setting: float) → pyrosetta.rosetta.core.id.DOF_ID

C++: core::kinematics::AtomTree::set_bond_angle(const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &, const double) –> class core::id::DOF_ID

set_bond_length(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1: pyrosetta.rosetta.core.id.AtomID, atom2: pyrosetta.rosetta.core.id.AtomID, setting: float) → pyrosetta.rosetta.core.id.DOF_ID

C++: core::kinematics::AtomTree::set_bond_length(const class core::id::AtomID &, const class core::id::AtomID &, const double) –> class core::id::DOF_ID

set_dof(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.DOF_ID, setting: float) → None

set a specific DOF in the tree

C++: core::kinematics::AtomTree::set_dof(const class core::id::DOF_ID &, const double) –> void

set_jump(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.AtomID, jump: pyrosetta.rosetta.core.kinematics.Jump) → None

set a specific jump transform

C++: core::kinematics::AtomTree::set_jump(const class core::id::AtomID &, const class core::kinematics::Jump &) –> void

set_jump_atom_stub_id(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.StubID) → None

C++: core::kinematics::AtomTree::set_jump_atom_stub_id(const class core::id::StubID &) –> void

set_jump_now(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.AtomID, jump: pyrosetta.rosetta.core.kinematics.Jump) → None

set a specific jump transform and immediately refold downstream atoms

C++: core::kinematics::AtomTree::set_jump_now(const class core::id::AtomID &, const class core::kinematics::Jump &) –> void

set_stub_transform(self: pyrosetta.rosetta.core.kinematics.AtomTree, stub_id1: pyrosetta.rosetta.core.id.StubID, stub_id2: pyrosetta.rosetta.core.id.StubID, target_rt: pyrosetta.rosetta.core.kinematics.RT) → pyrosetta.rosetta.core.id.AtomID

Set the transform between two stubs, returns the atomid of the jump atom which moved (for book-keeping)

C++: core::kinematics::AtomTree::set_stub_transform(const class core::id::StubID &, const class core::id::StubID &, const class core::kinematics::RT &) –> class core::id::AtomID

set_torsion_angle(*args, **kwargs)

Overloaded function.

1. set_torsion_angle(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1: pyrosetta.rosetta.core.id.AtomID, atom2: pyrosetta.rosetta.core.id.AtomID, atom3: pyrosetta.rosetta.core.id.AtomID, atom4: pyrosetta.rosetta.core.id.AtomID, setting: float) -> pyrosetta.rosetta.core.id.DOF_ID

2. set_torsion_angle(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1: pyrosetta.rosetta.core.id.AtomID, atom2: pyrosetta.rosetta.core.id.AtomID, atom3: pyrosetta.rosetta.core.id.AtomID, atom4: pyrosetta.rosetta.core.id.AtomID, setting: float, quiet: bool) -> pyrosetta.rosetta.core.id.DOF_ID

set a torsion angle “setting” to a specifc DOF derived by the four atoms

C++: core::kinematics::AtomTree::set_torsion_angle(const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &, const double, const bool) –> class core::id::DOF_ID

set_weak_pointer_to_self(self: pyrosetta.rosetta.core.kinematics.AtomTree, self_pointer: pyrosetta.rosetta.std.weak_ptr_const_core_kinematics_AtomTree_t) → None

Weak-pointer setter. The object that instantiates an owning pointer to an AtomTree object

must hand that AtomTree a weak pointer to itself so that the AtomTree may share that weak pointer with other AtomTrees. Such sharing allows for crucial speedups when copying between AtomTrees. If the object that instantiates this AtomTree does not provide it with a pointer-to-self, the AtomTree will still function, but it will not share its pointers properly.

C++: core::kinematics::AtomTree::set_weak_pointer_to_self(class std::weak_ptr<const class core::kinematics::AtomTree>) –> void

set_xyz(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.AtomID, xyz: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

set a specific atom xyz position

C++: core::kinematics::AtomTree::set_xyz(const class core::id::AtomID &, const class numeric::xyzVector<double> &) –> void

size(self: pyrosetta.rosetta.core.kinematics.AtomTree) → int

number of residues

C++: core::kinematics::AtomTree::size() const –> unsigned long

stub_from_id(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.StubID) → pyrosetta.rosetta.core.kinematics.Stub

C++: core::kinematics::AtomTree::stub_from_id(const class core::id::StubID &) const –> class core::kinematics::Stub

topological_match_to(self: pyrosetta.rosetta.core.kinematics.AtomTree) → pyrosetta.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.

C++: core::kinematics::AtomTree::topological_match_to() const –> class std::weak_ptr<const class core::kinematics::AtomTree>

topological_observers(self: pyrosetta.rosetta.core.kinematics.AtomTree) → pyrosetta.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.

C++: core::kinematics::AtomTree::topological_observers() const –> const class utility::vector1<class std::weak_ptr<const class core::kinematics::AtomTree>, class std::allocator<class std::weak_ptr<const class core::kinematics::AtomTree> > > &

torsion_angle(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1: pyrosetta.rosetta.core.id.AtomID, atom2: pyrosetta.rosetta.core.id.AtomID, atom3: pyrosetta.rosetta.core.id.AtomID, atom4: pyrosetta.rosetta.core.id.AtomID) → float

calculate torsion angle defined by four atoms in the atom tree

C++: core::kinematics::AtomTree::torsion_angle(const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &) const –> double

torsion_angle_dof_id(*args, **kwargs)

Overloaded function.

1. torsion_angle_dof_id(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1: pyrosetta.rosetta.core.id.AtomID, atom2: pyrosetta.rosetta.core.id.AtomID, atom3: pyrosetta.rosetta.core.id.AtomID, atom4: pyrosetta.rosetta.core.id.AtomID) -> pyrosetta.rosetta.core.id.DOF_ID

2. torsion_angle_dof_id(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1: pyrosetta.rosetta.core.id.AtomID, atom2: pyrosetta.rosetta.core.id.AtomID, atom3: pyrosetta.rosetta.core.id.AtomID, atom4: pyrosetta.rosetta.core.id.AtomID, quiet: bool) -> pyrosetta.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.

C++: core::kinematics::AtomTree::torsion_angle_dof_id(const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &, const bool) const –> class core::id::DOF_ID

3. torsion_angle_dof_id(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1_in_id: pyrosetta.rosetta.core.id.AtomID, atom2_in_id: pyrosetta.rosetta.core.id.AtomID, atom3_in_id: pyrosetta.rosetta.core.id.AtomID, atom4_in_id: pyrosetta.rosetta.core.id.AtomID, offset: float) -> pyrosetta.rosetta.core.id.DOF_ID

4. torsion_angle_dof_id(self: pyrosetta.rosetta.core.kinematics.AtomTree, atom1_in_id: pyrosetta.rosetta.core.id.AtomID, atom2_in_id: pyrosetta.rosetta.core.id.AtomID, atom3_in_id: pyrosetta.rosetta.core.id.AtomID, atom4_in_id: pyrosetta.rosetta.core.id.AtomID, offset: float, quiet: bool) -> pyrosetta.rosetta.core.id.DOF_ID

get the DOF_ID of a torsion angle given those four atoms which define this torsion

C++: core::kinematics::AtomTree::torsion_angle_dof_id(const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &, const class core::id::AtomID &, double &, const bool) const –> class core::id::DOF_ID

update_domain_map(self: pyrosetta.rosetta.core.kinematics.AtomTree, domain_map: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, dof_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, xyz_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t) → None

generates a “domain_map” defining the rigid body regions

whose internal coords have not changed, according to the informaiton in the two bool Mask’s update domain map from dof_moved and xyz_moved

C++: core::kinematics::AtomTree::update_domain_map(class ObjexxFCL::FArray1D<int> &, const class core::id::AtomID_Map<bool> &, const class core::id::AtomID_Map<bool> &) const –> void

update_sequence_numbering(self: pyrosetta.rosetta.core.kinematics.AtomTree, new_size: int, old2new: pyrosetta.rosetta.utility.vector1_int) → None

updates the Atom’s AtomID’s and the atom_pointer array

C++: core::kinematics::AtomTree::update_sequence_numbering(const unsigned long, const class utility::vector1<int, class std::allocator<int> > &) –> void

xyz(self: pyrosetta.rosetta.core.kinematics.AtomTree, id: pyrosetta.rosetta.core.id.AtomID) → pyrosetta.rosetta.numeric.xyzVector_double_t

get xyz position of an atom given its AtomID

C++: core::kinematics::AtomTree::xyz(const class core::id::AtomID &) const –> const class numeric::xyzVector<double> &

class pyrosetta.rosetta.core.kinematics.AtomWithDOFChange

Bases: pybind11_object

simple class for use in output-sensitive refold subroutine.

property atomid_

property reached_

class pyrosetta.rosetta.core.kinematics.EXCN_InvalidFoldTree

Bases: Exception

add_msg(self: pyrosetta.rosetta.utility.excn.Exception, str: str) → None

C++: utility::excn::Exception::add_msg(const std::string &) –> void

assign(self: pyrosetta.rosetta.core.kinematics.EXCN_InvalidFoldTree, : pyrosetta.rosetta.core.kinematics.EXCN_InvalidFoldTree) → pyrosetta.rosetta.core.kinematics.EXCN_InvalidFoldTree

C++: core::kinematics::EXCN_InvalidFoldTree::operator=(const class core::kinematics::EXCN_InvalidFoldTree &) –> class core::kinematics::EXCN_InvalidFoldTree &

bad_tree(self: pyrosetta.rosetta.core.kinematics.EXCN_InvalidFoldTree) → pyrosetta.rosetta.core.kinematics.FoldTree

C++: core::kinematics::EXCN_InvalidFoldTree::bad_tree() –> const class core::kinematics::FoldTree &

crash_log(self: pyrosetta.rosetta.utility.excn.Exception) → None

Invoke a crash log for throwing this exception.

If your exception is one which is a “non-error” exception, override this function to do nothing.

C++: utility::excn::Exception::crash_log() const –> void

display(self: pyrosetta.rosetta.utility.excn.Exception) → None

Present this exception to the user.

Will invoke crash log reporting, if applicable

C++: utility::excn::Exception::display() const –> void

file(self: pyrosetta.rosetta.utility.excn.Exception) → str

C++: utility::excn::Exception::file() –> const std::string &

line(self: pyrosetta.rosetta.utility.excn.Exception) → int

C++: utility::excn::Exception::line() –> int

msg(*args, **kwargs)

Overloaded function.

1. msg(self: pyrosetta.rosetta.utility.excn.Exception) -> str

Will return a formatted message (with file/line information)

C++: utility::excn::Exception::msg() const –> std::string

2. msg(self: pyrosetta.rosetta.utility.excn.Exception, m: str) -> None

Will set the raw message.

C++: utility::excn::Exception::msg(const std::string &) –> void

prepend_to_msg(self: pyrosetta.rosetta.utility.excn.Exception, str: str) → None

C++: utility::excn::Exception::prepend_to_msg(const std::string &) –> void

raw_msg(self: pyrosetta.rosetta.utility.excn.Exception) → str

Will return the raw message (without file/line information)

C++: utility::excn::Exception::raw_msg() const –> std::string

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.core.kinematics.EXCN_InvalidFoldTree, : pyrosetta.rosetta.std.ostream) -> None

2. show(self: pyrosetta.rosetta.core.kinematics.EXCN_InvalidFoldTree, os: pyrosetta.rosetta.std.ostream) -> None

C++: core::kinematics::EXCN_InvalidFoldTree::show(std::ostream &) –> void

traceback(self: pyrosetta.rosetta.utility.excn.Exception) → str

C++: utility::excn::Exception::traceback() –> const std::string &

what(self: pyrosetta.rosetta.std.exception) → str

C++: std::exception::what() const –> const char *

class pyrosetta.rosetta.core.kinematics.Edge

Bases: pybind11_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.

assign(self: pyrosetta.rosetta.core.kinematics.Edge, : pyrosetta.rosetta.core.kinematics.Edge) → pyrosetta.rosetta.core.kinematics.Edge

C++: core::kinematics::Edge::operator=(const class core::kinematics::Edge &) –> class core::kinematics::Edge &

downstream_atom(self: pyrosetta.rosetta.core.kinematics.Edge) → str

stop-atom, alt name, return by reference

C++: core::kinematics::Edge::downstream_atom() –> std::string &

has_atom_info(self: pyrosetta.rosetta.core.kinematics.Edge) → bool

edge has start and stop atoms?

C++: core::kinematics::Edge::has_atom_info() const –> bool

is_chemical_bond(self: pyrosetta.rosetta.core.kinematics.Edge) → bool

C++: core::kinematics::Edge::is_chemical_bond() const –> bool

is_jump(self: pyrosetta.rosetta.core.kinematics.Edge) → bool

edge is a jump?

C++: core::kinematics::Edge::is_jump() const –> bool

is_peptide(self: pyrosetta.rosetta.core.kinematics.Edge) → bool

Edge is peptide edge?

deprecated

C++: core::kinematics::Edge::is_peptide() const –> bool

is_polymer(self: pyrosetta.rosetta.core.kinematics.Edge) → bool

Edge is peptide edge?

C++: core::kinematics::Edge::is_polymer() const –> bool

keep_stub_in_residue(self: pyrosetta.rosetta.core.kinematics.Edge) → bool

C++: core::kinematics::Edge::keep_stub_in_residue() –> bool &

label(self: pyrosetta.rosetta.core.kinematics.Edge) → int

label (edge type), return by reference

C++: core::kinematics::Edge::label() –> int &

polymer_direction(self: pyrosetta.rosetta.core.kinematics.Edge) → int

direction for a continuous-segement edge. 1 if start residue number < stop residue number and -1 otherwise

C++: core::kinematics::Edge::polymer_direction() const –> int

start(self: pyrosetta.rosetta.core.kinematics.Edge) → int

start vertex, return by reference

C++: core::kinematics::Edge::start() –> unsigned long &

start_atom(self: pyrosetta.rosetta.core.kinematics.Edge) → str

start atom, return by reference

C++: core::kinematics::Edge::start_atom() –> std::string &

stop(self: pyrosetta.rosetta.core.kinematics.Edge) → int

stop vertex, return by reference

C++: core::kinematics::Edge::stop() –> unsigned long &

stop_atom(self: pyrosetta.rosetta.core.kinematics.Edge) → str

stop_atom, return by reference

C++: core::kinematics::Edge::stop_atom() –> std::string &

upstream_atom(self: pyrosetta.rosetta.core.kinematics.Edge) → str

start-atom, alt name, return by reference

C++: core::kinematics::Edge::upstream_atom() –> std::string &

valid(self: pyrosetta.rosetta.core.kinematics.Edge) → bool

Is this edge valid (false for default-constructed edges)

C++: core::kinematics::Edge::valid() const –> bool

class pyrosetta.rosetta.core.kinematics.FoldTree

Bases: pybind11_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

add_edge(*args, **kwargs)

Overloaded function.

1. add_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, start: int, stop: int, label: int) -> None

Adds an edge from <start> to <stop>

C++: core::kinematics::FoldTree::add_edge(const unsigned long, const unsigned long, const int) –> void

2. add_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, start: int, stop: int, start_atom: str, stop_atom: str) -> None

Especially useful version of add_edge for chemical edge construction

C++: core::kinematics::FoldTree::add_edge(const unsigned long, const unsigned long, const std::string &, const std::string &) –> void

3. add_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, start: int, stop: int, label: int, start_atom: str, stop_atom: str) -> None

Especially useful version of add_edge for chemical edge construction

Allows label.

Vikram K. Mulligan (vmulligan.org)

C++: core::kinematics::FoldTree::add_edge(const unsigned long, const unsigned long, const int, const std::string &, const std::string &) –> void

4. add_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, new_edge: pyrosetta.rosetta.core.kinematics.Edge) -> None

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

C++: core::kinematics::FoldTree::add_edge(const class core::kinematics::Edge &) –> void

append_residue(*args, **kwargs)

Overloaded function.

1. append_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree) -> None

2. append_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, attach_by_jump: bool) -> None

3. append_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, attach_by_jump: bool, jump_anchor_residue: int) -> None

4. append_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, attach_by_jump: bool, jump_anchor_residue: int, jump_upstream_atom: str) -> None

5. append_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, attach_by_jump: bool, jump_anchor_residue: int, jump_upstream_atom: str, jump_downstream_atom: str) -> None

Appends a new residue to the tree, either by a jump or as a continuation of a peptide segment

C++: core::kinematics::FoldTree::append_residue(const bool, const unsigned long, const std::string &, const std::string &) –> void

append_residue_by_chemical_bond(self: pyrosetta.rosetta.core.kinematics.FoldTree, anchor_residue: int, anchor_atom: str, root_atom: str) → None

Appends a new residue to the tree using a chemical (APL-style) connection

C++: core::kinematics::FoldTree::append_residue_by_chemical_bond(const unsigned long, const std::string &, const std::string &) –> void

apply_sequence_mapping(self: pyrosetta.rosetta.core.kinematics.FoldTree, old2new: pyrosetta.rosetta.core.id.SequenceMapping) → None

Renumber all vertices according to an input sequence mapping

C++: core::kinematics::FoldTree::apply_sequence_mapping(const class core::id::SequenceMapping &) –> void

assign(self: pyrosetta.rosetta.core.kinematics.FoldTree, src: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.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….

C++: core::kinematics::FoldTree::operator=(const class core::kinematics::FoldTree &) –> class core::kinematics::FoldTree &

boundary_left(self: pyrosetta.rosetta.core.kinematics.FoldTree, res: int) → int

Return the starting residue of the first kinematic Edge to which res belongs.

C++: core::kinematics::FoldTree::boundary_left(unsigned long) const –> unsigned long

boundary_right(self: pyrosetta.rosetta.core.kinematics.FoldTree, res: int) → int

Return the ending residue of the first kinematic Edge to which res belongs.

C++: core::kinematics::FoldTree::boundary_right(unsigned long) const –> unsigned long

check_edges_for_atom_info(self: pyrosetta.rosetta.core.kinematics.FoldTree) → bool

chemical edges should have atom info

C++: core::kinematics::FoldTree::check_edges_for_atom_info() const –> bool

check_fold_tree(self: pyrosetta.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

C++: core::kinematics::FoldTree::check_fold_tree() const –> bool

clear(self: pyrosetta.rosetta.core.kinematics.FoldTree) → None

Deletes all edge in the FoldTree

example(s):

ft.clear()

See also:

FoldTree FoldTree.add_edge FoldTree.check_fold_tree FoldTree.delete_edge FoldTree.new_jump FoldTree.nres FoldTree.num_jump FoldTree.simple_tree FoldTree.size

C++: core::kinematics::FoldTree::clear() –> void

clone(self: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.rosetta.core.kinematics.FoldTree

C++: core::kinematics::FoldTree::clone() –> class core::kinematics::FoldTree

connected(self: pyrosetta.rosetta.core.kinematics.FoldTree) → bool

Returns true if the FoldTree is connected

C++: core::kinematics::FoldTree::connected() const –> bool

count_fixed_residues(self: pyrosetta.rosetta.core.kinematics.FoldTree, begin_res: int, size: int, min_edge_count_out: int) → int

C++: core::kinematics::FoldTree::count_fixed_residues(const unsigned long, const unsigned long, unsigned long &) const –> unsigned long

cut_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, cut_point: int) → bool

helper function to try cutting an edge in a tree.

C++: core::kinematics::FoldTree::cut_edge(const unsigned long) –> bool

cutpoint(self: pyrosetta.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

C++: core::kinematics::FoldTree::cutpoint(const unsigned long) const –> unsigned long

cutpoint_by_jump(self: pyrosetta.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

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::cutpoint_by_jump(const unsigned long) const –> unsigned long

cutpoint_map(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) → int

cutpoint number for this residue

C++: core::kinematics::FoldTree::cutpoint_map(const unsigned long) const –> unsigned long

cutpoints(self: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.rosetta.utility.vector1_unsigned_long

get all cutpoints

C++: core::kinematics::FoldTree::cutpoints() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

delete_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, edge: pyrosetta.rosetta.core.kinematics.Edge) → None

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

C++: core::kinematics::FoldTree::delete_edge(const class core::kinematics::Edge &) –> void

delete_extra_vertices(self: pyrosetta.rosetta.core.kinematics.FoldTree) → None

Delete vertices that are no longer necessary any more

How is this determined?

C++: core::kinematics::FoldTree::delete_extra_vertices() –> void

delete_jump_and_intervening_cutpoint(*args, **kwargs)

Overloaded function.

1. delete_jump_and_intervening_cutpoint(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_begin: int, jump_end: int) -> None

2. delete_jump_and_intervening_cutpoint(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_begin: int, jump_end: int, cut: int) -> None

Useful for removing a loop modeling jump+cut

C++: core::kinematics::FoldTree::delete_jump_and_intervening_cutpoint(unsigned long, unsigned long, unsigned long) –> void

3. delete_jump_and_intervening_cutpoint(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int) -> None

Useful for removing a loop modeling jump+cut

C++: core::kinematics::FoldTree::delete_jump_and_intervening_cutpoint(const unsigned long) –> void

delete_segment(self: pyrosetta.rosetta.core.kinematics.FoldTree, seg_begin: int, seg_end: int) → None

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

C++: core::kinematics::FoldTree::delete_segment(const unsigned long, const unsigned long) –> void

delete_self_edges(self: pyrosetta.rosetta.core.kinematics.FoldTree) → None

Deletes edges with start==stop

allowable 1->1 edge for single residue FoldTree

C++: core::kinematics::FoldTree::delete_self_edges() –> void

delete_seqpos(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) → None

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

C++: core::kinematics::FoldTree::delete_seqpos(const unsigned long) –> void

delete_unordered_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, start: int, stop: int, label: int) → None

Find an edge in fold tree and delete it

C++: core::kinematics::FoldTree::delete_unordered_edge(const unsigned long, const unsigned long, const int) –> void

downstream_atom(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int) → str

the jump atom on the stopping side

C++: core::kinematics::FoldTree::downstream_atom(const unsigned long) const –> std::string

downstream_jump_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int) → int

the stopping residue for this jump

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::downstream_jump_residue(const unsigned long) const –> unsigned long

edge_label(self: pyrosetta.rosetta.core.kinematics.FoldTree, start: int, stop: int) → int

Returns the edge label of the edge from <start> to <stop>

C++: core::kinematics::FoldTree::edge_label(const unsigned long, const unsigned long) –> int

empty(self: pyrosetta.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

C++: core::kinematics::FoldTree::empty() const –> bool

get_chemical_edges(self: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.rosetta.utility.vector1_core_kinematics_Edge

Returns all chemical edges from fold tree

C++: core::kinematics::FoldTree::get_chemical_edges() const –> class utility::vector1<class core::kinematics::Edge, class std::allocator<class core::kinematics::Edge> >

get_jump_edges(self: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.rosetta.utility.vector1_core_kinematics_Edge

Return all jump Edges from the FoldTree

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::get_jump_edges() const –> class utility::vector1<class core::kinematics::Edge, class std::allocator<class core::kinematics::Edge> >

get_jump_that_builds_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) → int

Get the number of the jump that builds (connects to) a given residue

It’s an error if the residue isn’t built directly by a jump.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::get_jump_that_builds_residue(const unsigned long) const –> unsigned long

get_outgoing_edges(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) → pyrosetta.rosetta.utility.vector1_core_kinematics_Edge

Returns all edges that build a residue directly off of <seqpos>

C++: core::kinematics::FoldTree::get_outgoing_edges(const unsigned long) const –> class utility::vector1<class core::kinematics::Edge, class std::allocator<class core::kinematics::Edge> >

get_parent_residue(*args, **kwargs)

Overloaded function.

1. get_parent_residue(self: pyrosetta.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).

C++: core::kinematics::FoldTree::get_parent_residue(const unsigned long, bool &) const –> unsigned long

2. get_parent_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) -> int

Get the residue that is immediately upstream of this residue.

C++: core::kinematics::FoldTree::get_parent_residue(const unsigned long) const –> unsigned long

get_polymer_residue_direction(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) → int

Returns the direction (n2c, c2n) in which the given (peptide) residue is built during folding.

C++: core::kinematics::FoldTree::get_polymer_residue_direction(const unsigned long) const –> int

get_residue_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) → pyrosetta.rosetta.core.kinematics.Edge

Returns the edge that builds the residue <seqpos>

Does not work for root atom (will fail)

C++: core::kinematics::FoldTree::get_residue_edge(const unsigned long) const –> const class core::kinematics::Edge &

hash_value(self: pyrosetta.rosetta.core.kinematics.FoldTree) → int

computes a fixed-length, hash-based identifier for this FoldTree,

permitting efficient comparison between a pair of FoldTrees

C++: core::kinematics::FoldTree::hash_value() const –> unsigned long

insert_fold_tree_by_jump(*args, **kwargs)

Overloaded function.

1. insert_fold_tree_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, subtree: pyrosetta.rosetta.core.kinematics.FoldTree, insert_seqpos: int, insert_jumppos: int, anchor_pos: int) -> None

2. insert_fold_tree_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, subtree: pyrosetta.rosetta.core.kinematics.FoldTree, insert_seqpos: int, insert_jumppos: int, anchor_pos: int, anchor_jump_number: int) -> None

3. insert_fold_tree_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, subtree: pyrosetta.rosetta.core.kinematics.FoldTree, insert_seqpos: int, insert_jumppos: int, anchor_pos: int, anchor_jump_number: int, anchor_atom: str) -> None

4. insert_fold_tree_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, subtree: pyrosetta.rosetta.core.kinematics.FoldTree, insert_seqpos: int, insert_jumppos: int, anchor_pos: int, anchor_jump_number: int, anchor_atom: str, root_atom: str) -> None

Inserts a fold_tree as a subtree

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::insert_fold_tree_by_jump(const class core::kinematics::FoldTree &, const unsigned long, const unsigned long, const unsigned long, unsigned long, const std::string &, const std::string &) –> void

insert_polymer_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int, join_lower: bool, join_upper: bool) → None

Inserts a polymer residue at position <seqpos>

How?

C++: core::kinematics::FoldTree::insert_polymer_residue(const unsigned long, const bool, const bool) –> void

insert_residue_by_chemical_bond(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int, anchor_residue: int, anchor_atom: str, root_atom: str) → None

Inserts a bonded residue at position <seqpos>

C++: core::kinematics::FoldTree::insert_residue_by_chemical_bond(const unsigned long, const unsigned long, const std::string &, const std::string &) –> void

insert_residue_by_jump(*args, **kwargs)

Overloaded function.

1. insert_residue_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int, anchor_pos: int) -> None

2. insert_residue_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int, anchor_pos: int, anchor_atom: str) -> None

3. insert_residue_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int, anchor_pos: int, anchor_atom: str, root_atomno: str) -> None

Inserts a residue attached only by a jump. precondition is that seqpos-1 is a cutpoint

that anchor_pos is wrt the current numbering system (ie before insertion)

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::insert_residue_by_jump(const unsigned long, unsigned long, const std::string &, const std::string &) –> void

is_cutpoint(self: pyrosetta.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

C++: core::kinematics::FoldTree::is_cutpoint(const unsigned long) const –> bool

is_equivalent(self: pyrosetta.rosetta.core.kinematics.FoldTree, b: pyrosetta.rosetta.core.kinematics.FoldTree) → bool

Check if the two FoldTrees build in a similar fashion

That is, if their roots are the same and if all edges correspond to each other – Does not necessarily check that the order of the edges are the same.

C++: core::kinematics::FoldTree::is_equivalent(const class core::kinematics::FoldTree &) const –> bool

is_jump_point(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) → bool

Returns true if <seqpos> is a starting or stopping residue of a jump edge

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

example(s):

ft.is_jump_point()

See also:

FoldTree FoldTree.is_cutpoint FoldTree.new_jump FoldTree.num_jump

C++: core::kinematics::FoldTree::is_jump_point(const unsigned long) const –> bool

is_root(self: pyrosetta.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

C++: core::kinematics::FoldTree::is_root(const unsigned long) const –> bool

is_simple_tree(self: pyrosetta.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

C++: core::kinematics::FoldTree::is_simple_tree() const –> bool

jump_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int) → pyrosetta.rosetta.core.kinematics.Edge

Returns the jump edge with jump number <jump_number> (non-const)

C++: core::kinematics::FoldTree::jump_edge(const unsigned long) –> class core::kinematics::Edge &

jump_exists(self: pyrosetta.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

C++: core::kinematics::FoldTree::jump_exists(const unsigned long, const unsigned long) const –> bool

jump_nr(self: pyrosetta.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

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::jump_nr(unsigned long, unsigned long) const –> unsigned long

jump_point(self: pyrosetta.rosetta.core.kinematics.FoldTree, lower_higher: int, jump_number: int) → int

starting or stopping residue of a jump edge

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::jump_point(const unsigned long, const unsigned long) const –> unsigned long

new_chemical_bond(self: pyrosetta.rosetta.core.kinematics.FoldTree, anchor_pos: int, root_pos: int, anchor_atom: str, root_atom: str, new_cutpoint: int) → None

C++: core::kinematics::FoldTree::new_chemical_bond(const unsigned long, const unsigned long, const std::string &, const std::string &, const unsigned long) –> void

new_jump(self: pyrosetta.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>

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::new_jump(const unsigned long, const unsigned long, const unsigned long) –> unsigned long

nres(self: pyrosetta.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

C++: core::kinematics::FoldTree::nres() const –> unsigned long

num_cutpoint(self: pyrosetta.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

C++: core::kinematics::FoldTree::num_cutpoint() const –> unsigned long

num_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree) → int

Returns the number of jumps in the FoldTree

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

example(s):

ft.num_jump()

See also:

FoldTree FoldTree.check_fold_tree FoldTree.jump_edge FoldTree.new_jump FoldTree.nres

C++: core::kinematics::FoldTree::num_jump() const –> unsigned long

partition_by_jump(*args, **kwargs)

Overloaded function.

1. partition_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int, f1: pyrosetta.rosetta.core.kinematics.FoldTree, f2: pyrosetta.rosetta.core.kinematics.FoldTree) -> None

partition into two foldtrees by cutting at jump= jump_number

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::partition_by_jump(const unsigned long, class core::kinematics::FoldTree &, class core::kinematics::FoldTree &) const –> void

2. partition_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int, partner1: pyrosetta.rosetta.ObjexxFCL.FArray1D_bool_t) -> None

partition the fold tree in two parts if the jump is disconnected.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::partition_by_jump(const unsigned long, class ObjexxFCL::FArray1D<bool> &) const –> void

3. partition_by_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_nr: int) -> pyrosetta.rosetta.utility.vector1_bool

partition the fold tree in two parts if the jump is disconnected.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::partition_by_jump(const unsigned long) const –> class utility::vector1<bool, class std::allocator<bool> >

partition_by_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int, partner1: pyrosetta.rosetta.ObjexxFCL.FArray1D_bool_t) → None

partition the fold tree in two parts if a cut would be introduced between seqpos and seqpos+1

C++: core::kinematics::FoldTree::partition_by_residue(const unsigned long, class ObjexxFCL::FArray1D<bool> &) const –> void

partition_coloring(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_numbers: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.utility.vector1_unsigned_long

partition the fold tree into n parts based on specified jumps.

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::partition_coloring(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

possible_root(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) → bool

Returns true if <seqpos> is the root

C++: core::kinematics::FoldTree::possible_root(const unsigned long &) const –> bool

prepend_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, new_edge: pyrosetta.rosetta.core.kinematics.Edge) → None

Prepend the edge <new_edge>. Useful alternative to add_edge for setting root.

C++: core::kinematics::FoldTree::prepend_edge(const class core::kinematics::Edge &) –> void

put_jump_stubs_intra_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree) → None

this reorganizes upstream/downstream atoms of all jumps such that

stubs are N-CA-C

C++: core::kinematics::FoldTree::put_jump_stubs_intra_residue() –> void

random_tree_from_jump_points(*args, **kwargs)

Overloaded function.

1. random_tree_from_jump_points(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int, num_jump_in: int, jump_point: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t, cut_bias: pyrosetta.rosetta.ObjexxFCL.FArray1D_float_t) -> bool

2. random_tree_from_jump_points(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int, num_jump_in: int, jump_point: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t, cut_bias: pyrosetta.rosetta.ObjexxFCL.FArray1D_float_t, root_in: int) -> bool

3. random_tree_from_jump_points(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int, num_jump_in: int, jump_point: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t, cut_bias: pyrosetta.rosetta.ObjexxFCL.FArray1D_float_t, 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

C++: core::kinematics::FoldTree::random_tree_from_jump_points(const unsigned long, const unsigned long, const class ObjexxFCL::FArray2D<unsigned long> &, const class ObjexxFCL::FArray1D<float> &, const unsigned long, const bool) –> bool

4. random_tree_from_jump_points(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int, num_jump_in: int, jump_point: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t, obligate_cut_points: pyrosetta.rosetta.std.vector_unsigned_long, cut_bias: pyrosetta.rosetta.ObjexxFCL.FArray1D_float_t) -> bool

5. random_tree_from_jump_points(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int, num_jump_in: int, jump_point: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t, obligate_cut_points: pyrosetta.rosetta.std.vector_unsigned_long, cut_bias: pyrosetta.rosetta.ObjexxFCL.FArray1D_float_t, root_in: int) -> bool

6. random_tree_from_jump_points(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int, num_jump_in: int, jump_point: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t, obligate_cut_points: pyrosetta.rosetta.std.vector_unsigned_long, cut_bias: pyrosetta.rosetta.ObjexxFCL.FArray1D_float_t, 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

C++: core::kinematics::FoldTree::random_tree_from_jump_points(const unsigned long, const unsigned long, const class ObjexxFCL::FArray2D<unsigned long> &, const class std::vector<unsigned long, class std::allocator<unsigned long> > &, const class ObjexxFCL::FArray1D<float> &, const unsigned long, const bool) –> bool

reassign_atoms_for_intra_residue_stubs(self: pyrosetta.rosetta.core.kinematics.FoldTree) → None

this reorganizes upstream/downstream atoms of jumps that have flag

keep_stub_in_resiue = true such that stubs are N-CA-C

C++: core::kinematics::FoldTree::reassign_atoms_for_intra_residue_stubs() –> void

renumber_jumps(self: pyrosetta.rosetta.core.kinematics.FoldTree) → None

Renumbers the jump edges in the FoldTree

How?

C++: core::kinematics::FoldTree::renumber_jumps() –> void

renumber_jumps_ordered(self: pyrosetta.rosetta.core.kinematics.FoldTree) → None

Renumbers the jump edges in the FoldTree while

C++: core::kinematics::FoldTree::renumber_jumps_ordered() –> void

reorder(*args, **kwargs)

Overloaded function.

1. reorder(self: pyrosetta.rosetta.core.kinematics.FoldTree, start_residue: int) -> bool

2. reorder(self: pyrosetta.rosetta.core.kinematics.FoldTree, start_residue: int, verbose_if_fail: bool) -> bool

Reorders the FoldTree to start at residue <start_residue>

C++: core::kinematics::FoldTree::reorder(const unsigned long, const bool) –> bool

replace_edge(self: pyrosetta.rosetta.core.kinematics.FoldTree, old_edge: pyrosetta.rosetta.core.kinematics.Edge, replacement_edge: pyrosetta.rosetta.core.kinematics.Edge) → None

Find and replace an Edge in the FoldTree.

C++: core::kinematics::FoldTree::replace_edge(const class core::kinematics::Edge &, const class core::kinematics::Edge &) –> void

residue_is_in_fold_tree(self: pyrosetta.rosetta.core.kinematics.FoldTree, seqpos: int) → bool

Check if the seqpos is covered by an edge in the FoldTree

(Mainly useful for FoldTrees as they are being built.)

If true, seqpos is either the root or get_residue_edge() will return an edge.

C++: core::kinematics::FoldTree::residue_is_in_fold_tree(unsigned long) const –> bool

root(self: pyrosetta.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

C++: core::kinematics::FoldTree::root() const –> unsigned long

set_jump_atoms(*args, **kwargs)

Overloaded function.

1. set_jump_atoms(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int, upstream_atom: str, downstream_atom: str) -> None

2. set_jump_atoms(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int, upstream_atom: str, downstream_atom: str, bKeepStubInResidue: bool) -> None

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.

C++: core::kinematics::FoldTree::set_jump_atoms(const unsigned long, const std::string &, const std::string &, bool) –> void

3. set_jump_atoms(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int, res1: int, atom1: str, res2: int, atom2: str) -> None

4. set_jump_atoms(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int, res1: int, atom1: str, res2: int, atom2: str, bKeepStubInResidue: bool) -> None

C++: core::kinematics::FoldTree::set_jump_atoms(const unsigned long, unsigned long, const std::string &, unsigned long, const std::string &, bool) –> void

show(self: pyrosetta.rosetta.core.kinematics.FoldTree, out: pyrosetta.rosetta.std.ostream) → None

Displays the FoldTree information

example(s):

ft.show()

See Also:

Pose

C++: core::kinematics::FoldTree::show(std::ostream &) const –> void

simple_tree(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int) → None

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

C++: core::kinematics::FoldTree::simple_tree(const unsigned long) –> void

size(self: pyrosetta.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

C++: core::kinematics::FoldTree::size() const –> int

slide_cutpoint(self: pyrosetta.rosetta.core.kinematics.FoldTree, current_cut: int, target_cut: int) → None

Slide a polymer cutpoint from one location to another

C++: core::kinematics::FoldTree::slide_cutpoint(const unsigned long, const unsigned long) –> void

slide_jump(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int, new_res1: int, new_res2: int) → None

change an existing jump to start and end in new positions

C++: core::kinematics::FoldTree::slide_jump(const unsigned long, const unsigned long, const unsigned long) –> void

split_existing_edge_at_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, resNo: int) → None

Splits an edge into two at a specified position.

C++: core::kinematics::FoldTree::split_existing_edge_at_residue(const unsigned long) –> void

to_string(self: pyrosetta.rosetta.core.kinematics.FoldTree) → str

easy output of string

C++: core::kinematics::FoldTree::to_string() const –> std::string

tree_from_jumps_and_cuts(*args, **kwargs)

Overloaded function.

1. tree_from_jumps_and_cuts(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int, num_jump_in: int, jump_point: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t, cuts: pyrosetta.rosetta.ObjexxFCL.FArray1D_unsigned_long_t) -> bool

2. tree_from_jumps_and_cuts(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int, num_jump_in: int, jump_point: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t, cuts: pyrosetta.rosetta.ObjexxFCL.FArray1D_unsigned_long_t, root_in: int) -> bool

3. tree_from_jumps_and_cuts(self: pyrosetta.rosetta.core.kinematics.FoldTree, nres_in: int, num_jump_in: int, jump_point: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t, cuts: pyrosetta.rosetta.ObjexxFCL.FArray1D_unsigned_long_t, root_in: int, verbose: bool) -> bool

Constructs a FoldTree from listed <jump point> and <cuts>

Returns bool about success

C++: core::kinematics::FoldTree::tree_from_jumps_and_cuts(const unsigned long, const unsigned long, const class ObjexxFCL::FArray2D<unsigned long> &, const class ObjexxFCL::FArray1D<unsigned long> &, const unsigned long, const bool) –> bool

update_edge_label(self: pyrosetta.rosetta.core.kinematics.FoldTree, start: int, stop: int, old_label: int, new_label: int) → None

Changes the label of an edge in fold tree

C++: core::kinematics::FoldTree::update_edge_label(const unsigned long, const unsigned long, const int, const int) –> void

upstream_atom(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int) → str

the jump atom on the staring side

C++: core::kinematics::FoldTree::upstream_atom(const unsigned long) const –> std::string

upstream_jump_residue(self: pyrosetta.rosetta.core.kinematics.FoldTree, jump_number: int) → int

the starting residue for this jump

See the documentation of Pose::num_chains() for details about chain numbers, chain letters and jumps.

C++: core::kinematics::FoldTree::upstream_jump_residue(const unsigned long) const –> unsigned long

class pyrosetta.rosetta.core.kinematics.Jump

Bases: pybind11_object

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

See

assign(self: pyrosetta.rosetta.core.kinematics.Jump, : pyrosetta.rosetta.core.kinematics.Jump) → pyrosetta.rosetta.core.kinematics.Jump

copy operator

C++: core::kinematics::Jump::operator=(const class core::kinematics::Jump &) –> class core::kinematics::Jump &

fold_in_rb_deltas(self: pyrosetta.rosetta.core.kinematics.Jump) → None

transform small changes in translation and rotation into jump

C++: core::kinematics::Jump::fold_in_rb_deltas() –> void

from_bond_cst(self: pyrosetta.rosetta.core.kinematics.Jump, atoms: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t, csts: pyrosetta.rosetta.utility.vector1_double) → None

get a jump from a bond cst definition

C++: core::kinematics::Jump::from_bond_cst(class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class utility::vector1<double, class std::allocator<double> > &) –> void

from_stubs(self: pyrosetta.rosetta.core.kinematics.Jump, stub1: pyrosetta.rosetta.core.kinematics.Stub, stub2: pyrosetta.rosetta.core.kinematics.Stub) → None

get a jump from two stubs

C++: core::kinematics::Jump::from_stubs(const class core::kinematics::Stub &, const class core::kinematics::Stub &) –> void

gaussian_move(self: pyrosetta.rosetta.core.kinematics.Jump, dir: int, trans_mag: float, rot_mag: float) → pyrosetta.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

C++: core::kinematics::Jump::gaussian_move(const int, const float, const float) –> class utility::vector1<double, class std::allocator<double> >

gaussian_move_single_rb(self: pyrosetta.rosetta.core.kinematics.Jump, dir: int, mag: float, rb: int) → None

C++: core::kinematics::Jump::gaussian_move_single_rb(const int, const float, int) –> void

get_invert_downstream(self: pyrosetta.rosetta.core.kinematics.Jump) → bool

C++: core::kinematics::Jump::get_invert_downstream() const –> bool

get_invert_upstream(self: pyrosetta.rosetta.core.kinematics.Jump) → bool

C++: core::kinematics::Jump::get_invert_upstream() const –> bool

get_rb_center(self: pyrosetta.rosetta.core.kinematics.Jump, dir: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

get rb_center by direction

C++: core::kinematics::Jump::get_rb_center(const int) const –> const class numeric::xyzVector<double> &

get_rb_delta(*args, **kwargs)

Overloaded function.

1. get_rb_delta(self: pyrosetta.rosetta.core.kinematics.Jump, dir: int) -> pyrosetta.rosetta.utility.vector1_double

get rb_delta by direction

C++: core::kinematics::Jump::get_rb_delta(const int) const –> const class utility::vector1<double, class std::allocator<double> > &

2. get_rb_delta(self: pyrosetta.rosetta.core.kinematics.Jump, rb_no: int, dir: int) -> float

get rb_delta by direction and rb_number

C++: core::kinematics::Jump::get_rb_delta(const int, const int) const –> double

get_rotation(self: pyrosetta.rosetta.core.kinematics.Jump) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

get rotation matrix

C++: core::kinematics::Jump::get_rotation() const –> const class numeric::xyzMatrix<double> &

get_translation(self: pyrosetta.rosetta.core.kinematics.Jump) → pyrosetta.rosetta.numeric.xyzVector_double_t

get translation vector

C++: core::kinematics::Jump::get_translation() const –> const class numeric::xyzVector<double> &

identity_transform(self: pyrosetta.rosetta.core.kinematics.Jump) → None

reset to identity matrix, 0 translation

C++: core::kinematics::Jump::identity_transform() –> void

make_jump(self: pyrosetta.rosetta.core.kinematics.Jump, stub1: pyrosetta.rosetta.core.kinematics.Stub, stub2: pyrosetta.rosetta.core.kinematics.Stub) → None

make a jump from stub1 to stub2

C++: core::kinematics::Jump::make_jump(const class core::kinematics::Stub &, class core::kinematics::Stub &) const –> void

nonzero_deltas(self: pyrosetta.rosetta.core.kinematics.Jump) → bool

check whether there is rb_delta not being transformed.

C++: core::kinematics::Jump::nonzero_deltas() const –> bool

ortho_check(self: pyrosetta.rosetta.core.kinematics.Jump) → bool

check RT’s orthogonality

C++: core::kinematics::Jump::ortho_check() const –> bool

random_trans(self: pyrosetta.rosetta.core.kinematics.Jump, dist_in: float) → None

translate along a randomly chosen vector by dist_in

C++: core::kinematics::Jump::random_trans(const float) –> void

reset(self: pyrosetta.rosetta.core.kinematics.Jump) → None

reset RT, rb_delta and rb_center

C++: core::kinematics::Jump::reset() –> void

reverse(self: pyrosetta.rosetta.core.kinematics.Jump) → None

change the direction of a jump, e.g, upstream stub becomes downstream stub now.

C++: core::kinematics::Jump::reverse() –> void

reversed(self: pyrosetta.rosetta.core.kinematics.Jump) → pyrosetta.rosetta.core.kinematics.Jump

Return a new jump that is the inverse transformation

C++: core::kinematics::Jump::reversed() const –> class core::kinematics::Jump

rotation_by_axis(self: pyrosetta.rosetta.core.kinematics.Jump, stub: pyrosetta.rosetta.core.kinematics.Stub, axis: pyrosetta.rosetta.numeric.xyzVector_double_t, center: pyrosetta.rosetta.numeric.xyzVector_double_t, alpha: float) → None

make a rotation of alpha degrees around axix and center

C++: core::kinematics::Jump::rotation_by_axis(const class core::kinematics::Stub &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const float) –> void

rotation_by_matrix(self: pyrosetta.rosetta.core.kinematics.Jump, stub: pyrosetta.rosetta.core.kinematics.Stub, center: pyrosetta.rosetta.numeric.xyzVector_double_t, matrix: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None

make a rotation “matrix” about the center “center”

C++: core::kinematics::Jump::rotation_by_matrix(const class core::kinematics::Stub &, const class numeric::xyzVector<double> &, const class numeric::xyzMatrix<double> &) –> void

rt(self: pyrosetta.rosetta.core.kinematics.Jump) → pyrosetta.rosetta.core.kinematics.RT

return the RT modeled by this jump –> makes new Jump, calls fold_in_rb_delte and returns RT

C++: core::kinematics::Jump::rt() const –> class core::kinematics::RT

set_invert(self: pyrosetta.rosetta.core.kinematics.Jump, upstream: bool, downstream: bool) → None

C++: core::kinematics::Jump::set_invert(bool, bool) –> void

set_rb_center(self: pyrosetta.rosetta.core.kinematics.Jump, dir: int, stub: pyrosetta.rosetta.core.kinematics.Stub, center: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

set rb_center by direction

C++: core::kinematics::Jump::set_rb_center(const int, const class core::kinematics::Stub &, const class numeric::xyzVector<double> &) –> void

set_rb_delta(self: pyrosetta.rosetta.core.kinematics.Jump, rb_no: int, dir: int, value: float) → None

set rb_delta by direction and rb_number

C++: core::kinematics::Jump::set_rb_delta(const int, const int, const double) –> void

set_rb_deltas(self: pyrosetta.rosetta.core.kinematics.Jump, dir: int, : pyrosetta.rosetta.utility.vector1_double) → None

set rb_deltas by direction

C++: core::kinematics::Jump::set_rb_deltas(const int, const class utility::vector1<double, class std::allocator<double> > &) –> void

set_rotation(self: pyrosetta.rosetta.core.kinematics.Jump, R_in: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None

set rotation matrix

C++: core::kinematics::Jump::set_rotation(const class numeric::xyzMatrix<double> &) –> void

set_translation(self: pyrosetta.rosetta.core.kinematics.Jump, t: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

set translation vector

C++: core::kinematics::Jump::set_translation(const class numeric::xyzVector<double> &) –> void

translation_along_axis(self: pyrosetta.rosetta.core.kinematics.Jump, stub: pyrosetta.rosetta.core.kinematics.Stub, axis: pyrosetta.rosetta.numeric.xyzVector_double_t, dist: float) → None

make a translation along axis by dist

C++: core::kinematics::Jump::translation_along_axis(const class core::kinematics::Stub &, const class numeric::xyzVector<double> &, const float) –> void

class pyrosetta.rosetta.core.kinematics.MinimizerMapBase

Bases: pybind11_object

add_atom(self: pyrosetta.rosetta.core.kinematics.MinimizerMapBase, atom_id: pyrosetta.rosetta.core.id.AtomID, dof_id: pyrosetta.rosetta.core.id.DOF_ID) → None

Allow the AtomTree to inform this class that a particular atom belongs

in the derivative calculation for a certain DOF. That certain DOF must have already been included in the minimization process through a prior invocation of the add_torsion method.

C++: core::kinematics::MinimizerMapBase::add_atom(const class core::id::AtomID &, const class core::id::DOF_ID &) –> void

add_torsion(self: pyrosetta.rosetta.core.kinematics.MinimizerMapBase, new_torsion: pyrosetta.rosetta.core.id.DOF_ID, parent: pyrosetta.rosetta.core.id.DOF_ID) → None

Allow the AtomTree to communicate to this class that a particular torsion

(or angle or distance – a particular DOF) belongs in the minimization task to inform this class the parent DOF for that torsion.

C++: core::kinematics::MinimizerMapBase::add_torsion(const class core::id::DOF_ID &, const class core::id::DOF_ID &) –> void

assign(self: pyrosetta.rosetta.core.kinematics.MinimizerMapBase, : pyrosetta.rosetta.core.kinematics.MinimizerMapBase) → pyrosetta.rosetta.core.kinematics.MinimizerMapBase

C++: core::kinematics::MinimizerMapBase::operator=(const class core::kinematics::MinimizerMapBase &) –> class core::kinematics::MinimizerMapBase &

domain_map(self: pyrosetta.rosetta.core.kinematics.MinimizerMapBase) → pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t

C++: core::kinematics::MinimizerMapBase::domain_map() const –> const class ObjexxFCL::FArray1D<int> &

class pyrosetta.rosetta.core.kinematics.MoveMap

Bases: pybind11_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

assign(self: pyrosetta.rosetta.core.kinematics.MoveMap, : pyrosetta.rosetta.core.kinematics.MoveMap) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: core::kinematics::MoveMap::operator=(const class core::kinematics::MoveMap &) –> class core::kinematics::MoveMap &

clear(self: pyrosetta.rosetta.core.kinematics.MoveMap) → None

clear – sets all to FALSE

C++: core::kinematics::MoveMap::clear() –> void

clone(self: pyrosetta.rosetta.core.kinematics.MoveMap) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: core::kinematics::MoveMap::clone() const –> class std::shared_ptr<class core::kinematics::MoveMap>

get(*args, **kwargs)

Overloaded function.

1. get(self: pyrosetta.rosetta.core.kinematics.MoveMap, t: pyrosetta.rosetta.core.id.TorsionType) -> bool

get setting for a specific TorsionType, such as “BB”

C++: core::kinematics::MoveMap::get(const enum core::id::TorsionType &) const –> bool

2. get(self: pyrosetta.rosetta.core.kinematics.MoveMap, id: Tuple[int, pyrosetta.rosetta.core.id.TorsionType]) -> bool

get TorsionType flexible or fixed for one residue, eg BB torsions for residue 10

C++: core::kinematics::MoveMap::get(const struct std::pair<unsigned long, enum core::id::TorsionType> &) const –> bool

3. get(self: pyrosetta.rosetta.core.kinematics.MoveMap, id: pyrosetta.rosetta.core.id.TorsionID) -> bool

C++: core::kinematics::MoveMap::get(const class core::id::TorsionID &) const –> bool

4. get(self: pyrosetta.rosetta.core.kinematics.MoveMap, t: pyrosetta.rosetta.core.id.DOF_Type) -> bool

get the default for this type of DOF, eg “PHI”

C++: core::kinematics::MoveMap::get(const enum core::id::DOF_Type &) const –> bool

5. get(self: pyrosetta.rosetta.core.kinematics.MoveMap, id: pyrosetta.rosetta.core.id.DOF_ID) -> bool

get the setting for an individual dof, eg, PHI of Atom 3 in Residue 5

C++: core::kinematics::MoveMap::get(const class core::id::DOF_ID &) const –> bool

get_atoms(self: pyrosetta.rosetta.core.kinematics.MoveMap) → pyrosetta.rosetta.std.map_core_id_AtomID_bool

Get specific AtomID settings (used to set specific atoms in CartesianMin)

Per-atom interface not available to discourage general use IE - In order to ask if an ATOM is movable with the rest of the MM settings (as the other get functions do)

, one would require a pose.

C++: core::kinematics::MoveMap::get_atoms() const –> const class std::map<class core::id::AtomID, bool, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, bool> > > &

get_bb(*args, **kwargs)

Overloaded function.

1. get_bb(self: pyrosetta.rosetta.core.kinematics.MoveMap, seqpos: int) -> bool

Returns if BB torsions are movable or not for residue <seqpos>

example:

movemap.get_bb(49)

C++: core::kinematics::MoveMap::get_bb(const unsigned long) const –> bool

2. get_bb(self: pyrosetta.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)

C++: core::kinematics::MoveMap::get_bb(const unsigned long, const unsigned long) const –> bool

get_branches(self: pyrosetta.rosetta.core.kinematics.MoveMap, seqpos: int) → bool

Return if BRANCH torsions are movable or not for residue <seqpos>.

: Example: movemap.get_branches(49)

C++: core::kinematics::MoveMap::get_branches(const unsigned long) const –> bool

get_chi(self: pyrosetta.rosetta.core.kinematics.MoveMap, seqpos: int) → bool

Returns if SC torsions are movable or not for residue <seqpos>

example:

movemap.get_chi(49)

C++: core::kinematics::MoveMap::get_chi(const int) const –> bool

get_jump(*args, **kwargs)

Overloaded function.

1. get_jump(self: pyrosetta.rosetta.core.kinematics.MoveMap, jump_number: int) -> bool

Returns if JUMP <jump_number> is movable or not

example:

movemap.get_jump(1)

C++: core::kinematics::MoveMap::get_jump(const int) const –> bool

2. get_jump(self: pyrosetta.rosetta.core.kinematics.MoveMap, pos1: int, pos2: int) -> bool

C++: core::kinematics::MoveMap::get_jump(const unsigned long, const unsigned long) const –> bool

3. get_jump(self: pyrosetta.rosetta.core.kinematics.MoveMap, jump: pyrosetta.rosetta.core.id.JumpID) -> bool

C++: core::kinematics::MoveMap::get_jump(const class core::id::JumpID &) const –> bool

get_nu(self: pyrosetta.rosetta.core.kinematics.MoveMap, seqpos: int) → bool

Return if NU torsions are movable or not for residue <seqpos>.

: Example: movemap.get_nu(49)

C++: core::kinematics::MoveMap::get_nu(const unsigned long) const –> bool

import(self: pyrosetta.rosetta.core.kinematics.MoveMap, rval: pyrosetta.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.

C++: core::kinematics::MoveMap::import(const class core::kinematics::MoveMap &) –> unsigned long

import_false(self: pyrosetta.rosetta.core.kinematics.MoveMap, rval: pyrosetta.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.

C++: core::kinematics::MoveMap::import_false(const class core::kinematics::MoveMap &) –> unsigned long

import_true(self: pyrosetta.rosetta.core.kinematics.MoveMap, rval: pyrosetta.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.

C++: core::kinematics::MoveMap::import_true(const class core::kinematics::MoveMap &) –> unsigned long

init_from_file(self: pyrosetta.rosetta.core.kinematics.MoveMap, filename: str) → None

Read MoveMap from file.

C++: core::kinematics::MoveMap::init_from_file(const std::string &) –> void

set(*args, **kwargs)

Overloaded function.

1. set(self: pyrosetta.rosetta.core.kinematics.MoveMap, t: pyrosetta.rosetta.core.id.TorsionType, setting: bool) -> None

set a specific TorsionType movable: currently BB, CHI, NU, BRANCH, or JUMP

C++: core::kinematics::MoveMap::set(const enum core::id::TorsionType &, const bool) –> void

2. set(self: pyrosetta.rosetta.core.kinematics.MoveMap, id: Tuple[int, pyrosetta.rosetta.core.id.TorsionType], setting: bool) -> None

set TorsionType flexible or fixed for one residue, e.g., BB torsions for residue 10

C++: core::kinematics::MoveMap::set(const struct std::pair<unsigned long, enum core::id::TorsionType> &, const bool) –> void

3. set(self: pyrosetta.rosetta.core.kinematics.MoveMap, id: pyrosetta.rosetta.core.id.TorsionID, setting: bool) -> None

set an individual Torsion movable for now, e.g., “BB torsion 2 of residue 4”

C++: core::kinematics::MoveMap::set(const class core::id::TorsionID &, const bool) –> void

4. set(self: pyrosetta.rosetta.core.kinematics.MoveMap, t: pyrosetta.rosetta.core.id.DOF_Type, setting: bool) -> None

set atom tree DOF, e.g., D, PHI, THETA

C++: core::kinematics::MoveMap::set(const enum core::id::DOF_Type &, const bool) –> void

5. set(self: pyrosetta.rosetta.core.kinematics.MoveMap, id: pyrosetta.rosetta.core.id.DOF_ID, setting: bool) -> None

set for an individual DoF, e.g., “PHI of Atom 3 in Residue 5”

C++: core::kinematics::MoveMap::set(const class core::id::DOF_ID &, const bool) –> void

set_atom(self: pyrosetta.rosetta.core.kinematics.MoveMap, atom: pyrosetta.rosetta.core.id.AtomID, setting: bool) → None

Set a specific AtomID movable.

This is specifically for cartesian-space kinematics

C++: core::kinematics::MoveMap::set_atom(const class core::id::AtomID &, const bool) –> void

set_bb(*args, **kwargs)

Overloaded function.

1. set_bb(self: pyrosetta.rosetta.core.kinematics.MoveMap, setting: bool) -> None

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

C++: core::kinematics::MoveMap::set_bb(const bool) –> void

2. set_bb(self: pyrosetta.rosetta.core.kinematics.MoveMap, seqpos: int, setting: bool) -> None

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

C++: core::kinematics::MoveMap::set_bb(const unsigned long, const bool) –> void

3. set_bb(self: pyrosetta.rosetta.core.kinematics.MoveMap, seqpos: int, torsion_id: int, setting: bool) -> None

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

C++: core::kinematics::MoveMap::set_bb(const unsigned long, const unsigned long, const bool) –> void

4. set_bb(self: pyrosetta.rosetta.core.kinematics.MoveMap, allow_bb: pyrosetta.rosetta.utility.vector1_bool) -> None

Sets BB torsions movable based on input array

C++: core::kinematics::MoveMap::set_bb(class utility::vector1<bool, class std::allocator<bool> >) –> void

set_bb_true_range(self: pyrosetta.rosetta.core.kinematics.MoveMap, begin: int, end: int) → None

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

C++: core::kinematics::MoveMap::set_bb_true_range(const unsigned long, const unsigned long) –> void

set_branches(*args, **kwargs)

Overloaded function.

1. set_branches(self: pyrosetta.rosetta.core.kinematics.MoveMap, setting: bool) -> None

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

C++: core::kinematics::MoveMap::set_branches(const bool) –> void

2. set_branches(self: pyrosetta.rosetta.core.kinematics.MoveMap, seqpos: int, setting: bool) -> None

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

C++: core::kinematics::MoveMap::set_branches(const unsigned long, const bool) –> void

3. set_branches(self: pyrosetta.rosetta.core.kinematics.MoveMap, settings: pyrosetta.rosetta.utility.vector1_bool) -> None

Set which BRANCH torsions are movable based on input array.

C++: core::kinematics::MoveMap::set_branches(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

set_branches_true_range(self: pyrosetta.rosetta.core.kinematics.MoveMap, begin: int, end: int) → None

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

C++: core::kinematics::MoveMap::set_branches_true_range(const unsigned long, const unsigned long) –> void

set_chi(*args, **kwargs)

Overloaded function.

1. set_chi(self: pyrosetta.rosetta.core.kinematics.MoveMap, setting: bool) -> None

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

C++: core::kinematics::MoveMap::set_chi(const bool) –> void

2. set_chi(self: pyrosetta.rosetta.core.kinematics.MoveMap, seqpos: int, setting: bool) -> None

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

C++: core::kinematics::MoveMap::set_chi(const unsigned long, const bool) –> void

3. set_chi(self: pyrosetta.rosetta.core.kinematics.MoveMap, allow_chi: pyrosetta.rosetta.utility.vector1_bool) -> None

set CHI torsions movable based on input array

C++: core::kinematics::MoveMap::set_chi(class utility::vector1<bool, class std::allocator<bool> >) –> void

set_chi_true_range(self: pyrosetta.rosetta.core.kinematics.MoveMap, begin: int, end: int) → None

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

C++: core::kinematics::MoveMap::set_chi_true_range(const unsigned long, const unsigned long) –> void

set_jump(*args, **kwargs)

Overloaded function.

1. set_jump(self: pyrosetta.rosetta.core.kinematics.MoveMap, setting: bool) -> None

Sets whether or not JUMP TorsionType is moveable

example:

movemap.set_jump(True)

C++: core::kinematics::MoveMap::set_jump(const bool) –> void

2. set_jump(self: pyrosetta.rosetta.core.kinematics.MoveMap, jump_number: int, setting: bool) -> None

Sets the movability of JUMP <jump_number> to <setting>

example:

movemap.set_jump(1,True)

C++: core::kinematics::MoveMap::set_jump(const int, const bool) –> void

3. set_jump(self: pyrosetta.rosetta.core.kinematics.MoveMap, pos1: int, pos2: int, setting: bool) -> None

set JUMP moveable or not for one specific residue pair

this mechanism does not mix with the “jump_nr” mechanism… i.e., if you set jump_nr 3 = movable —> movemap does not know that this refers to say residue 23-89

C++: core::kinematics::MoveMap::set_jump(const unsigned long, const unsigned long, const bool) –> void

4. set_jump(self: pyrosetta.rosetta.core.kinematics.MoveMap, jump: pyrosetta.rosetta.core.id.JumpID, setting: bool) -> None

C++: core::kinematics::MoveMap::set_jump(const class core::id::JumpID &, const bool) –> void

set_nu(*args, **kwargs)

Overloaded function.

1. set_nu(self: pyrosetta.rosetta.core.kinematics.MoveMap, setting: bool) -> None

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

C++: core::kinematics::MoveMap::set_nu(const bool) –> void

2. set_nu(self: pyrosetta.rosetta.core.kinematics.MoveMap, seqpos: int, setting: bool) -> None

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

C++: core::kinematics::MoveMap::set_nu(const unsigned long, const bool) –> void

set_nu_true_range(self: pyrosetta.rosetta.core.kinematics.MoveMap, begin: int, end: int) → None

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

C++: core::kinematics::MoveMap::set_nu_true_range(const unsigned long, const unsigned long) –> void

set_nus(self: pyrosetta.rosetta.core.kinematics.MoveMap, settings: pyrosetta.rosetta.utility.vector1_bool) → None

Set which NU torsions are movable based on input array.

C++: core::kinematics::MoveMap::set_nus(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

set_ranges_unmodifiable(self: pyrosetta.rosetta.core.kinematics.MoveMap, ranges: pyrosetta.rosetta.std.vector_std_pair_unsigned_long_unsigned_long_t) → None

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.

C++: core::kinematics::MoveMap::set_ranges_unmodifiable(const class std::vector<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) –> void

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.core.kinematics.MoveMap, out: pyrosetta.rosetta.std.ostream, i: int) -> None

Give the TorsionType bool values up to a given residue number.

C++: core::kinematics::MoveMap::show(std::ostream &, unsigned long) const –> void

2. show(self: pyrosetta.rosetta.core.kinematics.MoveMap, i: int) -> None

Give the TorsionType bool values up to a given residue number.

wrapper for PyRosetta

C++: core::kinematics::MoveMap::show(unsigned long) const –> void

3. show(self: pyrosetta.rosetta.core.kinematics.MoveMap, out: pyrosetta.rosetta.std.ostream) -> None

C++: core::kinematics::MoveMap::show(std::ostream &) const –> void

4. show(self: pyrosetta.rosetta.core.kinematics.MoveMap) -> None

C++: core::kinematics::MoveMap::show() const –> void

class pyrosetta.rosetta.core.kinematics.RT

Bases: pybind11_object

as_array()

Convert self a numpy.array and return it.

Returns:

numpy.array: the 4x4 matrix representing the homogenous transform.

assign(self: pyrosetta.rosetta.core.kinematics.RT, : pyrosetta.rosetta.core.kinematics.RT) → pyrosetta.rosetta.core.kinematics.RT

copy operator

C++: core::kinematics::RT::operator=(const class core::kinematics::RT &) –> class core::kinematics::RT &

distance_squared(self: pyrosetta.rosetta.core.kinematics.RT, b: pyrosetta.rosetta.core.kinematics.RT) → float

C++: core::kinematics::RT::distance_squared(const class core::kinematics::RT &) const –> double

fold_in_rb_deltas(self: pyrosetta.rosetta.core.kinematics.RT, rb: pyrosetta.rosetta.utility.vector1_double, rb_center: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

update the transform to include small additional rigid-body rotations and translations

PHIL: IT WOULD BE GOOD TO ELIMINATE ARGUMENT ARRAYS IN MINI BY USE OF

APPROPRIATE LAYERED DATA STRUCTURES

C++: core::kinematics::RT::fold_in_rb_deltas(const class utility::vector1<double, class std::allocator<double> > &, const class numeric::xyzVector<double> &) –> void

from_stubs(self: pyrosetta.rosetta.core.kinematics.RT, stub1: pyrosetta.rosetta.core.kinematics.Stub, stub2: pyrosetta.rosetta.core.kinematics.Stub) → None

update from stubs

C++: core::kinematics::RT::from_stubs(const class core::kinematics::Stub &, const class core::kinematics::Stub &) –> void

get_rotation(self: pyrosetta.rosetta.core.kinematics.RT) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

get the rotation

C++: core::kinematics::RT::get_rotation() const –> const class numeric::xyzMatrix<double> &

get_translation(self: pyrosetta.rosetta.core.kinematics.RT) → pyrosetta.rosetta.numeric.xyzVector_double_t

get the translation

C++: core::kinematics::RT::get_translation() const –> const class numeric::xyzVector<double> &

identity_transform(self: pyrosetta.rosetta.core.kinematics.RT) → None

return to default-constructed state (another name)

C++: core::kinematics::RT::identity_transform() –> void

inverse(self: pyrosetta.rosetta.core.kinematics.RT) → None

reverse the “view”

C++: core::kinematics::RT::inverse() –> void

make_jump(self: pyrosetta.rosetta.core.kinematics.RT, stub1: pyrosetta.rosetta.core.kinematics.Stub, stub2: pyrosetta.rosetta.core.kinematics.Stub) → None

should be inverse of RT::from_stubs

C++: core::kinematics::RT::make_jump(const class core::kinematics::Stub &, class core::kinematics::Stub &) const –> void

ortho_check(self: pyrosetta.rosetta.core.kinematics.RT) → bool

check for orthogonality

C++: core::kinematics::RT::ortho_check() const –> bool

reset(self: pyrosetta.rosetta.core.kinematics.RT) → None

return to default-constructed state

C++: core::kinematics::RT::reset() –> void

reverse(self: pyrosetta.rosetta.core.kinematics.RT) → None

reverse the “view”

C++: core::kinematics::RT::reverse() –> void

set_rotation(self: pyrosetta.rosetta.core.kinematics.RT, r: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None

set the rotation

C++: core::kinematics::RT::set_rotation(const class numeric::xyzMatrix<double> &) –> void

set_translation(self: pyrosetta.rosetta.core.kinematics.RT, t: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

set the tranlsation

C++: core::kinematics::RT::set_translation(const class numeric::xyzVector<double> &) –> void

class pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList

Bases: pybind11_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.

assign(self: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList, rhs: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList) → pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList

C++: core::kinematics::ResidueCoordinateChangeList::operator=(const class core::kinematics::ResidueCoordinateChangeList &) –> class core::kinematics::ResidueCoordinateChangeList &

clear(self: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList) → None

Reset the list of those residues that have moved. O(k).

C++: core::kinematics::ResidueCoordinateChangeList::clear() –> void

empty(self: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList) → bool

Is the list of the changed residues empty?

C++: core::kinematics::ResidueCoordinateChangeList::empty() const –> bool

mark_residue_moved(*args, **kwargs)

Overloaded function.

1. mark_residue_moved(self: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList, atid: pyrosetta.rosetta.core.id.AtomID) -> None

Mark a residue as having changed by passing in an AtomId for one atom

in that residue

C++: core::kinematics::ResidueCoordinateChangeList::mark_residue_moved(class core::id::AtomID) –> void

2. mark_residue_moved(self: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList, resid: int) -> None

Mark a residue as having changed by passing in the index of that residue.

C++: core::kinematics::ResidueCoordinateChangeList::mark_residue_moved(unsigned long) –> void

total_residue(*args, **kwargs)

Overloaded function.

1. total_residue(self: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList, total_residue: int) -> None

Set the number of residues in the conformation being tracked.

C++: core::kinematics::ResidueCoordinateChangeList::total_residue(unsigned long) –> void

2. total_residue(self: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList) -> int

Return the number of

C++: core::kinematics::ResidueCoordinateChangeList::total_residue() const –> unsigned long

class pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) → pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree

C++: core::kinematics::ShortestPathInFoldTree::operator=(const class core::kinematics::ShortestPathInFoldTree &) –> class core::kinematics::ShortestPathInFoldTree &

dist(self: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, pos1: int, pos2: int) → int

returns the shortest distance of two residues going along Fold-Tree edges.

C++: core::kinematics::ShortestPathInFoldTree::dist(unsigned long, unsigned long) const –> unsigned long

max_dist(self: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) → int

returns the shortest distance for the two residues that are furthest apart

C++: core::kinematics::ShortestPathInFoldTree::max_dist() const –> unsigned long

class pyrosetta.rosetta.core.kinematics.Stub

Bases: pybind11_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

property M

assign(self: pyrosetta.rosetta.core.kinematics.Stub, : pyrosetta.rosetta.core.kinematics.Stub) → pyrosetta.rosetta.core.kinematics.Stub

C++: core::kinematics::Stub::operator=(const class core::kinematics::Stub &) –> class core::kinematics::Stub &

build_fake_xyz(*args, **kwargs)

Overloaded function.

1. build_fake_xyz(self: pyrosetta.rosetta.core.kinematics.Stub, index: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Build stubatom coords that would yield this stub

C++: core::kinematics::Stub::build_fake_xyz(const unsigned long) const –> class numeric::xyzVector<double>

2. build_fake_xyz(self: pyrosetta.rosetta.core.kinematics.Stub, index: int, length1: float, length2: float, angle_degrees: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Build stubatom coords that would yield this stub

C++: core::kinematics::Stub::build_fake_xyz(const unsigned long, const double, const double, const double) const –> class numeric::xyzVector<double>

center(self: pyrosetta.rosetta.core.kinematics.Stub) → pyrosetta.rosetta.numeric.xyzVector_double_t

Coordinate frame center.

C++: core::kinematics::Stub::center() const –> class numeric::xyzVector<double>

static create_orthogonal(a: pyrosetta.rosetta.numeric.xyzVector_double_t, b: pyrosetta.rosetta.numeric.xyzVector_double_t, c: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.core.kinematics.Stub

constructor by three points

Like the three-point constructor, but adjust things to make sure the stub is orthoganal

C++: core::kinematics::Stub::create_orthogonal(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class core::kinematics::Stub

from_four_points(self: pyrosetta.rosetta.core.kinematics.Stub, center: pyrosetta.rosetta.numeric.xyzVector_double_t, a: pyrosetta.rosetta.numeric.xyzVector_double_t, b: pyrosetta.rosetta.numeric.xyzVector_double_t, c: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

build a stub from a center and other three points a, b, c

C++: core::kinematics::Stub::from_four_points(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> void

global2local(self: pyrosetta.rosetta.core.kinematics.Stub, xyz: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t

convert a global reference (lab) frame vector to our local (stub) frame

C++: core::kinematics::Stub::global2local(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

is_orthogonal(self: pyrosetta.rosetta.core.kinematics.Stub, tolerance: float) → bool

check if the stub is orthogonal under the tolerance cutoff

C++: core::kinematics::Stub::is_orthogonal(const double &) const –> bool

local2global(self: pyrosetta.rosetta.core.kinematics.Stub, xyz: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t

convert a local reference (stub) frame vector to the global (lab) frame

C++: core::kinematics::Stub::local2global(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

rotation(self: pyrosetta.rosetta.core.kinematics.Stub) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

Coordinate frame rotation matrix.

C++: core::kinematics::Stub::rotation() const –> class numeric::xyzMatrix<double>

spherical(self: pyrosetta.rosetta.core.kinematics.Stub, phi: float, theta: float, d: float) → pyrosetta.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

C++: core::kinematics::Stub::spherical(const double, const double, const double) const –> class numeric::xyzVector<double>

property v

pyrosetta.rosetta.core.kinematics.ZERO() → pyrosetta.rosetta.utility.vector1_double

C++: core::kinematics::ZERO() –> const class utility::vector1<double, class std::allocator<double> > &

pyrosetta.rosetta.core.kinematics.add_atom(atomno: int, seqpos: int, links: pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t, atom_ptr: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_kinematics_tree_Atom_t, add_jump_atom: bool) → pyrosetta.rosetta.core.kinematics.tree.Atom

creat an atom and add it to the residue atom-tree based on information stored in links.

C++: core::kinematics::add_atom(const int, const int, const class utility::vector1<class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class std::allocator<class utility::vector1<unsigned long, class std::allocator<unsigned long> > > > &, class utility::vector1<class std::shared_ptr<class core::kinematics::tree::Atom>, class std::allocator<class std::shared_ptr<class core::kinematics::tree::Atom> > > &, const bool) –> class std::shared_ptr<class core::kinematics::tree::Atom>

pyrosetta.rosetta.core.kinematics.deep_copy(source: core::kinematics::MoveMap) → core::kinematics::MoveMap

C++: core::kinematics::deep_copy(const class core::kinematics::MoveMap &) –> class std::shared_ptr<class core::kinematics::MoveMap>

pyrosetta.rosetta.core.kinematics.distance(*args, **kwargs)

Overloaded function.

1. distance(a: pyrosetta.rosetta.core.kinematics.Stub, b: pyrosetta.rosetta.core.kinematics.Stub) -> float

root squared deviation between two stubs

C++: core::kinematics::distance(const class core::kinematics::Stub &, const class core::kinematics::Stub &) –> double

2. distance(a: pyrosetta.rosetta.core.kinematics.RT, b: pyrosetta.rosetta.core.kinematics.RT) -> float

C++: core::kinematics::distance(const class core::kinematics::RT &, const class core::kinematics::RT &) –> double

3. distance(a_in: pyrosetta.rosetta.core.kinematics.Jump, b_in: pyrosetta.rosetta.core.kinematics.Jump) -> float

RT root squared deviation

C++: core::kinematics::distance(const class core::kinematics::Jump &, const class core::kinematics::Jump &) –> double

pyrosetta.rosetta.core.kinematics.get_foldtree_which_partitions(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, residues: pyrosetta.rosetta.utility.vector1_bool) → pyrosetta.rosetta.core.kinematics.FoldTree

Return a new FoldTree where a single jump separates the residues in the passed set from those

not in the passed set.

The current root residue is preserved. If you want the passed residue set on a particular side of the jump, you can always call FoldTree::reorder() to re-root the FoldTree on the appropriate side.

C++: core::kinematics::get_foldtree_which_partitions(const class core::kinematics::FoldTree &, class utility::vector1<bool, class std::allocator<bool> >) –> class core::kinematics::FoldTree

pyrosetta.rosetta.core.kinematics.get_residues_from_movemap_bb_any_torsion(movemap: pyrosetta.rosetta.core.kinematics.MoveMap, total_resnum: int) → pyrosetta.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.

Jared Adolf-Bryfogle

C++: core::kinematics::get_residues_from_movemap_bb_any_torsion(const class core::kinematics::MoveMap &, unsigned long) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.kinematics.get_residues_from_movemap_bb_or_chi(movemap: pyrosetta.rosetta.core.kinematics.MoveMap, total_resnum: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

Get residues that are on in the movemap, either for BB, Any Specific torsion (up to 4) or CHI.

Jared Adolf-Bryfogle

C++: core::kinematics::get_residues_from_movemap_bb_or_chi(const class core::kinematics::MoveMap &, unsigned long) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.kinematics.get_residues_from_movemap_with_id(query_torsion: pyrosetta.rosetta.core.id.TorsionType, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → pyrosetta.rosetta.utility.vector1_unsigned_long

Get a vector of residues matching the id from a movemap.

Jared Adolf-Bryfogle

C++: core::kinematics::get_residues_from_movemap_with_id(enum core::id::TorsionType, const class core::kinematics::MoveMap &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.kinematics.jump_distance(a_in: pyrosetta.rosetta.core.kinematics.Jump, b_in: pyrosetta.rosetta.core.kinematics.Jump, dist: float, theta: float) → None

compare the difference of two jumps in term of the translation (dist) and rotational angle(theta)

C++: core::kinematics::jump_distance(const class core::kinematics::Jump &, const class core::kinematics::Jump &, double &, double &) –> void

pyrosetta.rosetta.core.kinematics.jump_which_partitions(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, residues: pyrosetta.rosetta.utility.vector1_bool) → int

Return the jump which separates the residues in the passed residue selection from all the ones which are not.

If no such jump exists (e.g. there’s a mixture of included/excluded residues on both sides of every jump) then return zero. Note that upstream/downstream is not specified - you can check this later.

C++: core::kinematics::jump_which_partitions(const class core::kinematics::FoldTree &, class utility::vector1<bool, class std::allocator<bool> >) –> unsigned long

pyrosetta.rosetta.core.kinematics.linearize_fold_tree(tree: pyrosetta.rosetta.core.kinematics.FoldTree) → pyrosetta.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

C++: core::kinematics::linearize_fold_tree(const class core::kinematics::FoldTree &) –> class core::kinematics::FoldTree

pyrosetta.rosetta.core.kinematics.pick_loopy_cutpoint(n_res: int, cut_bias_sum: pyrosetta.rosetta.ObjexxFCL.FArray1D_float_t) → int

C++: core::kinematics::pick_loopy_cutpoint(const unsigned long, const class ObjexxFCL::FArray1D<float> &) –> int

pyrosetta.rosetta.core.kinematics.remodel_fold_tree_to_account_for_insertion(input_tree: pyrosetta.rosetta.core.kinematics.FoldTree, insert_after: int, insert_size: int) → pyrosetta.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

C++: core::kinematics::remodel_fold_tree_to_account_for_insertion(const class core::kinematics::FoldTree &, unsigned long, unsigned long) –> class core::kinematics::FoldTree

pyrosetta.rosetta.core.kinematics.residues_downstream_of_jump(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, jump_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return a list of residue numbers which are on the downstream side of the jump.

C++: core::kinematics::residues_downstream_of_jump(const class core::kinematics::FoldTree &, unsigned long) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.kinematics.residues_upstream_of_jump(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, jump_id: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return a list of residue numbers which are on the upstream side of the jump.

C++: core::kinematics::residues_upstream_of_jump(const class core::kinematics::FoldTree &, unsigned long) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.kinematics.simple_visualize_fold_tree(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, out: pyrosetta.rosetta.std.ostream) → None

prints something like this *1***C***1*********2***C********3****C****2********3***

C++: core::kinematics::simple_visualize_fold_tree(const class core::kinematics::FoldTree &, std::ostream &) –> void

pyrosetta.rosetta.core.kinematics.simple_visualize_fold_tree_and_movemap(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, mm: pyrosetta.rosetta.core.kinematics.MoveMap, out: pyrosetta.rosetta.std.ostream) → None

prints something like this *1***C***1*********2***C********3****C****2********3***

********xxxxxxxxxxxxx**********************************

C++: core::kinematics::simple_visualize_fold_tree_and_movemap(const class core::kinematics::FoldTree &, const class core::kinematics::MoveMap &, std::ostream &) –> void

pyrosetta.rosetta.core.kinematics.simple_visualize_fold_tree_and_movemap_bb_chi(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, mm: pyrosetta.rosetta.core.kinematics.MoveMap, out: pyrosetta.rosetta.std.ostream) → None

prints something like this *1***C***1*********2***C********3****C****2********3***

********xxxxxxxxxxxxx**********************************

C++: core::kinematics::simple_visualize_fold_tree_and_movemap_bb_chi(const class core::kinematics::FoldTree &, const class core::kinematics::MoveMap &, std::ostream &) –> void

pyrosetta.rosetta.core.kinematics.visualize_fold_tree(*args, **kwargs)

Overloaded function.

1. visualize_fold_tree(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree) -> str

sheffler

C++: core::kinematics::visualize_fold_tree(const class core::kinematics::FoldTree &) –> std::string

2. visualize_fold_tree(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, node_labels_partial: pyrosetta.rosetta.std.map_unsigned_long_std_string) -> str

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

3. visualize_fold_tree(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, mark_jump_to_res: pyrosetta.rosetta.std.map_unsigned_long_char) -> str

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

4. visualize_fold_tree(fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree, node_labels_partial: pyrosetta.rosetta.std.map_unsigned_long_std_string, mark_jump_to_res: pyrosetta.rosetta.std.map_unsigned_long_char, jump_follows: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) -> str

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