tree

Bindings for core::kinematics::tree namespace

class pyrosetta.rosetta.core.kinematics.tree.Atom

Bases: pybind11_object

Kinematics Atom interface class

append_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

C++: core::kinematics::tree::Atom::append_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

atom_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.id.AtomID

Atom identifier

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

atom_is_on_path_from_root(self: pyrosetta.rosetta.core.kinematics.tree.Atom, atm: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

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

child(self: pyrosetta.rosetta.core.kinematics.tree.Atom, k: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom::child(const unsigned long) –> class std::shared_ptr<class core::kinematics::tree::Atom>

child_index(self: pyrosetta.rosetta.core.kinematics.tree.Atom, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

the atom-index of this child

C++: core::kinematics::tree::Atom::child_index(class std::shared_ptr<const class core::kinematics::tree::Atom>) const –> unsigned long

clone(self: pyrosetta.rosetta.core.kinematics.tree.Atom, parent_in: pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t, atom_pointer: pyrosetta.rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) → pyrosetta.rosetta.core.kinematics.tree.Atom

copy atom with new memory allocation

C++: core::kinematics::tree::Atom::clone(class std::weak_ptr<class core::kinematics::tree::Atom>, class core::id::AtomID_Map<class std::shared_ptr<class core::kinematics::tree::Atom> > &) const –> class std::shared_ptr<class core::kinematics::tree::Atom>

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

copy DOFs and xyz coords from src Atom

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

delete_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

C++: core::kinematics::tree::Atom::delete_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

dfs(self: pyrosetta.rosetta.core.kinematics.tree.Atom, changeset: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange, res_change_list: core::kinematics::ResidueCoordinateChangeList, start_atom_index: int) → None

Perform a depth-first traversal of the tree that would be effected by

a DOF change from this atom. Stop at atoms that have already been traversed.

C++: core::kinematics::tree::Atom::dfs(class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &, class core::kinematics::ResidueCoordinateChangeList &, const unsigned long) const –> void

dihedral_between_bonded_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom, child1: pyrosetta.rosetta.core.kinematics.tree.Atom, child2: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

dihedral angle between two bonded children to this atom

C++: core::kinematics::tree::Atom::dihedral_between_bonded_children(const class core::kinematics::tree::Atom &, const class core::kinematics::tree::Atom &) const –> double

distance(self: pyrosetta.rosetta.core.kinematics.tree.Atom, atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance to an Atom

C++: core::kinematics::tree::Atom::distance(const class core::kinematics::tree::Atom &) const –> double

distance_squared(self: pyrosetta.rosetta.core.kinematics.tree.Atom, atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance squared to an Atom

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

dof(self: pyrosetta.rosetta.core.kinematics.tree.Atom, type: pyrosetta.rosetta.core.id.DOF_Type) → float

get dof

C++: core::kinematics::tree::Atom::dof(const enum core::id::DOF_Type) const –> double

downstream(self: pyrosetta.rosetta.core.kinematics.tree.Atom, atom1: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

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

get_dof_axis_and_end_pos(self: pyrosetta.rosetta.core.kinematics.tree.Atom, axis: pyrosetta.rosetta.numeric.xyzVector_double_t, end_pos: pyrosetta.rosetta.numeric.xyzVector_double_t, type: pyrosetta.rosetta.core.id.DOF_Type) → None

C++: core::kinematics::tree::Atom::get_dof_axis_and_end_pos(class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const enum core::id::DOF_Type) const –> void

get_input_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.Stub

C++: core::kinematics::tree::Atom::get_input_stub() const –> class core::kinematics::Stub

get_nonjump_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom, i: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom::get_nonjump_atom(const unsigned long) const –> class std::shared_ptr<const class core::kinematics::tree::Atom>

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

C++: core::kinematics::tree::Atom::get_self_ptr() –> class std::shared_ptr<class core::kinematics::tree::Atom>

get_self_weak_ptr(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t

C++: core::kinematics::tree::Atom::get_self_weak_ptr() –> class std::weak_ptr<class core::kinematics::tree::Atom>

get_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.Stub

Get stub information

C++: core::kinematics::tree::Atom::get_stub() const –> class core::kinematics::Stub

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.core.kinematics.tree.Atom) -> pyrosetta.rosetta.core.id.AtomID

Atom identifier

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

2. id(self: pyrosetta.rosetta.core.kinematics.tree.Atom, id_in: pyrosetta.rosetta.core.id.AtomID) -> None

AtomID assignment

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

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

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

input_stub_atom0_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.id.AtomID

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

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

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

input_stub_atom1_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.id.AtomID

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

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

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

input_stub_atom2_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.id.AtomID

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

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

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

input_stub_atom3_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.id.AtomID

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

insert_atom(*args, **kwargs)

Overloaded function.

1. insert_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom, : pyrosetta.rosetta.core.kinematics.tree.Atom) -> None

C++: core::kinematics::tree::Atom::insert_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

2. insert_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom, : pyrosetta.rosetta.core.kinematics.tree.Atom, : int) -> None

C++: core::kinematics::tree::Atom::insert_atom(class std::shared_ptr<class core::kinematics::tree::Atom>, const int) –> void

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

atom is a jump atom?

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

jump(*args, **kwargs)

Overloaded function.

1. jump(self: pyrosetta.rosetta.core.kinematics.tree.Atom) -> pyrosetta.rosetta.core.kinematics.Jump

get Jump

C++: core::kinematics::tree::Atom::jump() const –> const class core::kinematics::Jump &

2. jump(self: pyrosetta.rosetta.core.kinematics.tree.Atom, jump_in: pyrosetta.rosetta.core.kinematics.Jump) -> None

set Jump

C++: core::kinematics::tree::Atom::jump(const class core::kinematics::Jump &) –> void

3. jump(self: pyrosetta.rosetta.core.kinematics.tree.Atom, jump_in: pyrosetta.rosetta.core.kinematics.Jump, set: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> None

set Jump – for use in output-sensitive refolding

C++: core::kinematics::tree::Atom::jump(const class core::kinematics::Jump &, class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &) –> void

keep_1st_child_pos(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

when other atoms are inserted insert after 1st child if available.

–> this enables us to keep a stub of Downstream Jump atoms inside a single residue

C++: core::kinematics::tree::Atom::keep_1st_child_pos() const –> bool

keep_dof_fixed(self: pyrosetta.rosetta.core.kinematics.tree.Atom, : pyrosetta.rosetta.core.id.DOF_Type) → bool

DoF should be fixed for this atom?

for DoFs that must be kept fixed due to topology of tree e.g., phi of stub_atoms for jump_atoms

C++: core::kinematics::tree::Atom::keep_dof_fixed(const enum core::id::DOF_Type) const –> bool

n_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

C++: core::kinematics::tree::Atom::n_atom() const –> unsigned long

n_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

C++: core::kinematics::tree::Atom::n_children() const –> unsigned long

n_nonjump_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

C++: core::kinematics::tree::Atom::n_nonjump_children() const –> unsigned long

next_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

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

parent(*args, **kwargs)

Overloaded function.

1. parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom, parent_in: pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t) -> None

parent assignment

C++: core::kinematics::tree::Atom::parent(class std::weak_ptr<class core::kinematics::tree::Atom>) –> void

2. parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom) -> pyrosetta.rosetta.core.kinematics.tree.Atom

Parent atom pointer, NULL for root atom

C++: core::kinematics::tree::Atom::parent() –> class std::shared_ptr<class core::kinematics::tree::Atom>

position(*args, **kwargs)

Overloaded function.

1. position(self: pyrosetta.rosetta.core.kinematics.tree.Atom) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Position

C++: core::kinematics::tree::Atom::position() const –> const class numeric::xyzVector<double> &

2. position(self: pyrosetta.rosetta.core.kinematics.tree.Atom, position_a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Position assignment

C++: core::kinematics::tree::Atom::position(const class numeric::xyzVector<double> &) –> void

previous_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

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

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

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

raw_child_index(self: pyrosetta.rosetta.core.kinematics.tree.Atom, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

the atom-index of this child

C++: core::kinematics::tree::Atom::raw_child_index(const class core::kinematics::tree::Atom *) const –> unsigned long

raw_get_nonjump_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom, i: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

Rapid (increment-of-reference-count-avoiding) access to the ith non-jump atom in this atom’s

list of children.

C++: core::kinematics::tree::Atom::raw_get_nonjump_atom(const unsigned long) const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the 0th input stub atom;

C++: core::kinematics::tree::Atom::raw_input_stub_atom0() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the 1st input stub atom;

C++: core::kinematics::tree::Atom::raw_input_stub_atom1() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the 2nd input stub atom;

C++: core::kinematics::tree::Atom::raw_input_stub_atom2() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the 3rd input stub atom;

C++: core::kinematics::tree::Atom::raw_input_stub_atom3() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the parent atom pointer

C++: core::kinematics::tree::Atom::raw_parent() const –> const class core::kinematics::tree::Atom *

raw_previous_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

Rapid (increment-of-reference-count-avoiding) access to the previous child pointer;

C++: core::kinematics::tree::Atom::raw_previous_child(const class core::kinematics::tree::Atom *) const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the previous sibling pointer,

i.e. the first child in the parent’s children list to precede this atom.

C++: core::kinematics::tree::Atom::raw_previous_sibling() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the fist stub atom

C++: core::kinematics::tree::Atom::raw_stub_atom1() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the second stub atom

C++: core::kinematics::tree::Atom::raw_stub_atom2() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the third stub atom

C++: core::kinematics::tree::Atom::raw_stub_atom3() const –> const class core::kinematics::tree::Atom *

replace_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom, old_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, new_atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

C++: core::kinematics::tree::Atom::replace_atom(const class std::shared_ptr<class core::kinematics::tree::Atom>, const class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

set_dof(*args, **kwargs)

Overloaded function.

1. set_dof(self: pyrosetta.rosetta.core.kinematics.tree.Atom, type: pyrosetta.rosetta.core.id.DOF_Type, value: float) -> None

set dof, use “set_” syntax since we have multiple dof’s

C++: core::kinematics::tree::Atom::set_dof(const enum core::id::DOF_Type, const double) –> void

2. set_dof(self: pyrosetta.rosetta.core.kinematics.tree.Atom, type: pyrosetta.rosetta.core.id.DOF_Type, value: float, set: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> None

set dof, use “set_” syntax since we have multiple dof’s – for use in output-sensitive refold routine

C++: core::kinematics::tree::Atom::set_dof(const enum core::id::DOF_Type, const double, class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &) –> void

setup_min_map(self: pyrosetta.rosetta.core.kinematics.tree.Atom, last_torsion: pyrosetta.rosetta.core.id.DOF_ID, move_map: pyrosetta.rosetta.core.id.DOF_ID_Map_bool_t, min_map: core::kinematics::MinimizerMapBase) → None

C++: core::kinematics::tree::Atom::setup_min_map(class core::id::DOF_ID &, const class core::id::DOF_ID_Map<bool> &, class core::kinematics::MinimizerMapBase &) const –> void

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

copy atom with new memory allocation

Only copies the atom, without copying or connecting atom to the parent or children atoms Intended primarily as an internal implementation detail of clone()

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.core.kinematics.tree.Atom) -> None

dump out AtomID for this atom, its parent and all its offspring

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

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

dump out AtomID for this atom, its parent and all its offspring up to n_level

C++: core::kinematics::tree::Atom::show(const int &) const –> void

steal_inversion(self: pyrosetta.rosetta.core.kinematics.tree.Atom, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

C++: core::kinematics::tree::Atom::steal_inversion(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

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

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

stub_atom1_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.id.AtomID

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

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

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

stub_atom2_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.id.AtomID

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

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

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

stub_atom3_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.id.AtomID

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

stub_defined(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

C++: core::kinematics::tree::Atom::stub_defined() const –> bool

transform_Ax_plus_b_recursive(self: pyrosetta.rosetta.core.kinematics.tree.Atom, A: pyrosetta.rosetta.numeric.xyzMatrix_double_t, b: pyrosetta.rosetta.numeric.xyzVector_double_t, res_change_list: core::kinematics::ResidueCoordinateChangeList) → None

Transform atom and children by linear transformation

C++: core::kinematics::tree::Atom::transform_Ax_plus_b_recursive(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &, class core::kinematics::ResidueCoordinateChangeList &) –> void

update_domain_map(self: pyrosetta.rosetta.core.kinematics.tree.Atom, current_color: int, biggest_color: int, domain_map: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, dof_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, atom_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t) → None

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

update_internal_coords(*args, **kwargs)

Overloaded function.

1. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom, stub: pyrosetta.rosetta.core.kinematics.Stub) -> None

2. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom, stub: pyrosetta.rosetta.core.kinematics.Stub, recursive: bool) -> None

Update internal coordinates for this atom and possibly all children.

If recursive is true, we update children, grandchildren, great-grandchildren, etc., but we don’t use a recursive algorithm.

Vikram K. Mulligan (vmulligan.org).

C++: core::kinematics::tree::Atom::update_internal_coords(class core::kinematics::Stub &, const bool) –> void

3. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom, recursive: bool) -> None

calculate my input_stub from the current xyz’s and use that input_stub to update my torsions

C++: core::kinematics::tree::Atom::update_internal_coords(const bool) –> void

update_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom, stub: pyrosetta.rosetta.core.kinematics.Stub) → None

update the stub without actually updating coordinates

C++: core::kinematics::tree::Atom::update_stub(class core::kinematics::Stub &) const –> void

update_xyz_coords(*args, **kwargs)

Overloaded function.

1. update_xyz_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom) -> None

The atom must retrieve an appropriate stub from its parent; it is the root

of the subtree being refolded

C++: core::kinematics::tree::Atom::update_xyz_coords() –> void

2. update_xyz_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom, stub: pyrosetta.rosetta.core.kinematics.Stub) -> None

update xyz coords from stub and internal coords and

C++: core::kinematics::tree::Atom::update_xyz_coords(class core::kinematics::Stub &) –> void

x(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

x coordinate

C++: core::kinematics::tree::Atom::x() const –> const double &

xyz(*args, **kwargs)

Overloaded function.

1. xyz(self: pyrosetta.rosetta.core.kinematics.tree.Atom) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Position

C++: core::kinematics::tree::Atom::xyz() const –> const class numeric::xyzVector<double> &

2. xyz(self: pyrosetta.rosetta.core.kinematics.tree.Atom, position_a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Position assignment

C++: core::kinematics::tree::Atom::xyz(const class numeric::xyzVector<double> &) –> void

y(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

y coordinate

C++: core::kinematics::tree::Atom::y() const –> const double &

z(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

z coordinate

C++: core::kinematics::tree::Atom::z() const –> const double &

class pyrosetta.rosetta.core.kinematics.tree.Atom_

Bases: Atom

Kinematics Atom abstract base class

append_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

append an atom as this atom’s child

C++: core::kinematics::tree::Atom_::append_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

atom_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

Atom identifier

C++: core::kinematics::tree::Atom_::atom_id() const –> const class core::id::AtomID &

atom_is_on_path_from_root(self: pyrosetta.rosetta.core.kinematics.tree.Atom, atm: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

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

child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, k: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

get a child atom by index

C++: core::kinematics::tree::Atom_::child(const unsigned long) –> class std::shared_ptr<class core::kinematics::tree::Atom>

child_index(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

the atom-index of this child

C++: core::kinematics::tree::Atom_::child_index(class std::shared_ptr<const class core::kinematics::tree::Atom>) const –> unsigned long

clone(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, parent_in: pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t, atom_pointer: pyrosetta.rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) → pyrosetta.rosetta.core.kinematics.tree.Atom

copy atom with new memory allocation

C++: core::kinematics::tree::Atom_::clone(class std::weak_ptr<class core::kinematics::tree::Atom>, class core::id::AtomID_Map<class std::shared_ptr<class core::kinematics::tree::Atom> > &) const –> class std::shared_ptr<class core::kinematics::tree::Atom>

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

copy DOFs and xyz coords from src Atom

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

delete_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

remove an atom from this atom’s children

C++: core::kinematics::tree::Atom_::delete_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

dfs(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, changeset: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange, res_change_list: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList, start_atom_index: int) → None

base class implementation that traverses the subtree routed at this node

in the depth-first traversal of the atoms requiring coordinate updates.

C++: core::kinematics::tree::Atom_::dfs(class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &, class core::kinematics::ResidueCoordinateChangeList &, const unsigned long) const –> void

dihedral_between_bonded_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child1: pyrosetta.rosetta.core.kinematics.tree.Atom, child2: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

dihedral angle between two bonded children to this atom

C++: core::kinematics::tree::Atom_::dihedral_between_bonded_children(const class core::kinematics::tree::Atom &, const class core::kinematics::tree::Atom &) const –> double

distance(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance to an Atom

C++: core::kinematics::tree::Atom_::distance(const class core::kinematics::tree::Atom &) const –> double

distance_squared(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance squared to an Atom

C++: core::kinematics::tree::Atom_::distance_squared(const class core::kinematics::tree::Atom &) const –> double

dof(self: pyrosetta.rosetta.core.kinematics.tree.Atom, type: pyrosetta.rosetta.core.id.DOF_Type) → float

get dof

C++: core::kinematics::tree::Atom::dof(const enum core::id::DOF_Type) const –> double

downstream(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, atom1: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

whether atom1 is downstream of this atom.

C++: core::kinematics::tree::Atom_::downstream(class std::shared_ptr<const class core::kinematics::tree::Atom>) const –> bool

get_dof_axis_and_end_pos(self: pyrosetta.rosetta.core.kinematics.tree.Atom, axis: pyrosetta.rosetta.numeric.xyzVector_double_t, end_pos: pyrosetta.rosetta.numeric.xyzVector_double_t, type: pyrosetta.rosetta.core.id.DOF_Type) → None

C++: core::kinematics::tree::Atom::get_dof_axis_and_end_pos(class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const enum core::id::DOF_Type) const –> void

get_input_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.Stub

stub used to build this atom

C++: core::kinematics::tree::Atom_::get_input_stub() const –> class core::kinematics::Stub

get_nonjump_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, i: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

get non-jump atom by its index from the children atoms list

C++: core::kinematics::tree::Atom_::get_nonjump_atom(const unsigned long) const –> class std::shared_ptr<const class core::kinematics::tree::Atom>

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

C++: core::kinematics::tree::Atom::get_self_ptr() –> class std::shared_ptr<class core::kinematics::tree::Atom>

get_self_weak_ptr(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t

C++: core::kinematics::tree::Atom::get_self_weak_ptr() –> class std::weak_ptr<class core::kinematics::tree::Atom>

get_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.Stub

stub centerd at this atom

C++: core::kinematics::tree::Atom_::get_stub() const –> class core::kinematics::Stub

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.core.id.AtomID

Atom identifier

C++: core::kinematics::tree::Atom_::id() const –> const class core::id::AtomID &

2. id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, id_in: pyrosetta.rosetta.core.id.AtomID) -> None

AtomID assignment

C++: core::kinematics::tree::Atom_::id(const class core::id::AtomID &) –> void

input_stub_atom0(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the center of the input stub for refolding this atom

it is its parent

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

input_stub_atom0_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom0’s id

C++: core::kinematics::tree::Atom_::input_stub_atom0_id() const –> const class core::id::AtomID &

input_stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the first atom to construct the input stub for refolding this atom

it is its parent’s stub_atom1, which normally the parent itself

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

input_stub_atom1_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom1’s id

C++: core::kinematics::tree::Atom_::input_stub_atom1_id() const –> const class core::id::AtomID &

input_stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the second atom to construct the input stub for refolding this atom

it is its parent’s stub_atom2, which normally the parent’s parent

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

input_stub_atom2_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom2’s id

C++: core::kinematics::tree::Atom_::input_stub_atom2_id() const –> const class core::id::AtomID &

input_stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the third atom to construct the input stub for refolding this atom

it is either its previous sibling or its parent’s stub_atom3,

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

input_stub_atom3_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom3’s id

C++: core::kinematics::tree::Atom_::input_stub_atom3_id() const –> const class core::id::AtomID &

insert_atom(*args, **kwargs)

Overloaded function.

1. insert_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom) -> None

insert an atom as this atom’s child

C++: core::kinematics::tree::Atom_::insert_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

2. insert_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom, : int) -> None

tries to insert at the position specified by the second argument

C++: core::kinematics::tree::Atom_::insert_atom(class std::shared_ptr<class core::kinematics::tree::Atom>, const int) –> void

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

atom is a jump atom?

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

jump(*args, **kwargs)

Overloaded function.

1. jump(self: pyrosetta.rosetta.core.kinematics.tree.Atom) -> pyrosetta.rosetta.core.kinematics.Jump

get Jump

C++: core::kinematics::tree::Atom::jump() const –> const class core::kinematics::Jump &

2. jump(self: pyrosetta.rosetta.core.kinematics.tree.Atom, jump_in: pyrosetta.rosetta.core.kinematics.Jump) -> None

set Jump

C++: core::kinematics::tree::Atom::jump(const class core::kinematics::Jump &) –> void

3. jump(self: pyrosetta.rosetta.core.kinematics.tree.Atom, jump_in: pyrosetta.rosetta.core.kinematics.Jump, set: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> None

set Jump – for use in output-sensitive refolding

C++: core::kinematics::tree::Atom::jump(const class core::kinematics::Jump &, class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &) –> void

keep_1st_child_pos(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

when other atoms are inserted insert after 1st child if available.

–> this enables us to keep a stub of Downstream Jump atoms inside a single residue

C++: core::kinematics::tree::Atom::keep_1st_child_pos() const –> bool

keep_dof_fixed(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.id.DOF_Type) → bool

for DOFs which must be kept fixed due to topology of tree

eg, phi of stub_atoms for jump_atoms

C++: core::kinematics::tree::Atom_::keep_dof_fixed(const enum core::id::DOF_Type) const –> bool

n_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → int

number of children atoms

C++: core::kinematics::tree::Atom_::n_atom() const –> unsigned long

n_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → int

number of the child atoms

C++: core::kinematics::tree::Atom_::n_children() const –> unsigned long

n_nonjump_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → int

number of the non-jump child atoms

C++: core::kinematics::tree::Atom_::n_nonjump_children() const –> unsigned long

next_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

find the child atom after this child in the list

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

parent(*args, **kwargs)

Overloaded function.

1. parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.core.kinematics.tree.Atom

Parent atom pointer

C++: core::kinematics::tree::Atom_::parent() –> class std::shared_ptr<class core::kinematics::tree::Atom>

2. parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, parent_in: pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t) -> None

C++: core::kinematics::tree::Atom_::parent(class std::weak_ptr<class core::kinematics::tree::Atom>) –> void

position(*args, **kwargs)

Overloaded function.

1. position(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Position

C++: core::kinematics::tree::Atom_::position() const –> const class numeric::xyzVector<double> &

2. position(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, position_a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Position assignment

C++: core::kinematics::tree::Atom_::position(const class numeric::xyzVector<double> &) –> void

previous_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

find the child atom before this child in the list

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

previous_sibling(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

routines for navigating the tree

find the sibling atom before itself

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

raw_child_index(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

the atom-index of this child

C++: core::kinematics::tree::Atom_::raw_child_index(const class core::kinematics::tree::Atom *) const –> unsigned long

raw_get_nonjump_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, i: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_get_nonjump_atom(const unsigned long) const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom0(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom0() const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom1() const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom2() const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom3() const –> const class core::kinematics::tree::Atom *

raw_parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_parent() const –> const class core::kinematics::tree::Atom *

raw_previous_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_previous_child(const class core::kinematics::tree::Atom *) const –> const class core::kinematics::tree::Atom *

raw_previous_sibling(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_previous_sibling() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the fist stub atom

C++: core::kinematics::tree::Atom::raw_stub_atom1() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the second stub atom

C++: core::kinematics::tree::Atom::raw_stub_atom2() const –> const class core::kinematics::tree::Atom *

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

Rapid (increment-of-reference-count-avoiding) access to the third stub atom

C++: core::kinematics::tree::Atom::raw_stub_atom3() const –> const class core::kinematics::tree::Atom *

replace_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, old_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, new_atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

replace the old atom by the new atom in the child atom list

C++: core::kinematics::tree::Atom_::replace_atom(const class std::shared_ptr<class core::kinematics::tree::Atom>, const class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

set_dof(*args, **kwargs)

Overloaded function.

1. set_dof(self: pyrosetta.rosetta.core.kinematics.tree.Atom, type: pyrosetta.rosetta.core.id.DOF_Type, value: float) -> None

set dof, use “set_” syntax since we have multiple dof’s

C++: core::kinematics::tree::Atom::set_dof(const enum core::id::DOF_Type, const double) –> void

2. set_dof(self: pyrosetta.rosetta.core.kinematics.tree.Atom, type: pyrosetta.rosetta.core.id.DOF_Type, value: float, set: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> None

set dof, use “set_” syntax since we have multiple dof’s – for use in output-sensitive refold routine

C++: core::kinematics::tree::Atom::set_dof(const enum core::id::DOF_Type, const double, class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &) –> void

setup_min_map(self: pyrosetta.rosetta.core.kinematics.tree.Atom, last_torsion: pyrosetta.rosetta.core.id.DOF_ID, move_map: pyrosetta.rosetta.core.id.DOF_ID_Map_bool_t, min_map: core::kinematics::MinimizerMapBase) → None

C++: core::kinematics::tree::Atom::setup_min_map(class core::id::DOF_ID &, const class core::id::DOF_ID_Map<bool> &, class core::kinematics::MinimizerMapBase &) const –> void

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

copy atom with new memory allocation

Only copies the atom, without copying or connecting atom to the parent or children atoms Intended primarily as an internal implementation detail of clone()

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> None

dump out AtomID for this atom, its parent and all its offspring

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

2. show(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, n_level: int) -> None

dump out AtomID for this atom, its parent and all its offspring up to n_level

C++: core::kinematics::tree::Atom_::show(const int &) const –> void

steal_inversion(self: pyrosetta.rosetta.core.kinematics.tree.Atom, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

C++: core::kinematics::tree::Atom::steal_inversion(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

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

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

stub_atom1_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

stub atom1 ‘s id

C++: core::kinematics::tree::Atom_::stub_atom1_id() const –> const class core::id::AtomID &

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

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

stub_atom2_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

stub atom2’s id

C++: core::kinematics::tree::Atom_::stub_atom2_id() const –> const class core::id::AtomID &

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

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

stub_atom3_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

stub atom3’s id

C++: core::kinematics::tree::Atom_::stub_atom3_id() const –> const class core::id::AtomID &

stub_defined(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → bool

whether a Stub can be defined for this atom

C++: core::kinematics::tree::Atom_::stub_defined() const –> bool

transform_Ax_plus_b_recursive(self: pyrosetta.rosetta.core.kinematics.tree.Atom, A: pyrosetta.rosetta.numeric.xyzMatrix_double_t, b: pyrosetta.rosetta.numeric.xyzVector_double_t, res_change_list: core::kinematics::ResidueCoordinateChangeList) → None

Transform atom and children by linear transformation

C++: core::kinematics::tree::Atom::transform_Ax_plus_b_recursive(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &, class core::kinematics::ResidueCoordinateChangeList &) –> void

update_domain_map(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, current_color: int, biggest_color: int, domain_map: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, dof_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, atom_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t) → None

update domain map

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

update_internal_coords(*args, **kwargs)

Overloaded function.

1. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, recursive: bool) -> None

update internal coords of this atom and its offspring atoms (if recursive)

C++: core::kinematics::tree::Atom_::update_internal_coords(const bool) –> void

2. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, stub: pyrosetta.rosetta.core.kinematics.Stub) -> None

3. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, stub: pyrosetta.rosetta.core.kinematics.Stub, recursive: bool) -> None

Update internal coordinates for this atom and possibly all children.

If recursive is true, we update children, grandchildren, great-grandchildren, etc., but we don’t use a recursive algorithm.

Vikram K. Mulligan (vmulligan.org).

C++: core::kinematics::tree::Atom_::update_internal_coords(class core::kinematics::Stub &, const bool) –> void

update_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom, stub: pyrosetta.rosetta.core.kinematics.Stub) → None

update the stub without actually updating coordinates

C++: core::kinematics::tree::Atom::update_stub(class core::kinematics::Stub &) const –> void

update_xyz_coords(*args, **kwargs)

Overloaded function.

1. update_xyz_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, stub: pyrosetta.rosetta.core.kinematics.Stub) -> None

2. update_xyz_coords(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> None

update xyz position of this atom and its offspring atoms

C++: core::kinematics::tree::Atom_::update_xyz_coords() –> void

x(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → float

x coordinate

C++: core::kinematics::tree::Atom_::x() const –> const double &

xyz(*args, **kwargs)

Overloaded function.

1. xyz(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Position

C++: core::kinematics::tree::Atom_::xyz() const –> const class numeric::xyzVector<double> &

2. xyz(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, position_a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Position assignment

C++: core::kinematics::tree::Atom_::xyz(const class numeric::xyzVector<double> &) –> void

y(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → float

y coordinate

C++: core::kinematics::tree::Atom_::y() const –> const double &

z(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → float

z coordinate

C++: core::kinematics::tree::Atom_::z() const –> const double &

class pyrosetta.rosetta.core.kinematics.tree.BondedAtom

Bases: Atom_

an atom which are bonded to its parent, derived from Atom_

See

append_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

append an atom as this atom’s child

C++: core::kinematics::tree::Atom_::append_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

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

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

atom_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

Atom identifier

C++: core::kinematics::tree::Atom_::atom_id() const –> const class core::id::AtomID &

atom_is_on_path_from_root(self: pyrosetta.rosetta.core.kinematics.tree.Atom, atm: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

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

child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, k: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

get a child atom by index

C++: core::kinematics::tree::Atom_::child(const unsigned long) –> class std::shared_ptr<class core::kinematics::tree::Atom>

child_index(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

the atom-index of this child

C++: core::kinematics::tree::Atom_::child_index(class std::shared_ptr<const class core::kinematics::tree::Atom>) const –> unsigned long

clone(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, parent_in: pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t, atom_pointer: pyrosetta.rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) → pyrosetta.rosetta.core.kinematics.tree.Atom

copy atom with new memory allocation

C++: core::kinematics::tree::Atom_::clone(class std::weak_ptr<class core::kinematics::tree::Atom>, class core::id::AtomID_Map<class std::shared_ptr<class core::kinematics::tree::Atom> > &) const –> class std::shared_ptr<class core::kinematics::tree::Atom>

copy_coords(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, src: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

copy DOFs, xyz’s

C++: core::kinematics::tree::BondedAtom::copy_coords(const class core::kinematics::tree::Atom &) –> void

delete_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

remove an atom from this atom’s children

C++: core::kinematics::tree::Atom_::delete_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

dfs(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, changeset: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange, res_change_list: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList, start_atom_index: int) → None

Perform a depth-first traversal of the tree that would be effected by

a DOF change from this atom. Stop at atoms that have already been traversed. Will recurse on younger siblings if a phi on this atom has changed.

C++: core::kinematics::tree::BondedAtom::dfs(class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &, class core::kinematics::ResidueCoordinateChangeList &, const unsigned long) const –> void

dihedral_between_bonded_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child1: pyrosetta.rosetta.core.kinematics.tree.Atom, child2: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

dihedral angle between two bonded children to this atom

C++: core::kinematics::tree::Atom_::dihedral_between_bonded_children(const class core::kinematics::tree::Atom &, const class core::kinematics::tree::Atom &) const –> double

distance(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance to an Atom

C++: core::kinematics::tree::Atom_::distance(const class core::kinematics::tree::Atom &) const –> double

distance_squared(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance squared to an Atom

C++: core::kinematics::tree::Atom_::distance_squared(const class core::kinematics::tree::Atom &) const –> double

dof(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, type: pyrosetta.rosetta.core.id.DOF_Type) → float

get degrees of freedom

C++: core::kinematics::tree::BondedAtom::dof(const enum core::id::DOF_Type) const –> double

downstream(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, atom1: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

whether atom1 is downstream of this atom.

C++: core::kinematics::tree::Atom_::downstream(class std::shared_ptr<const class core::kinematics::tree::Atom>) const –> bool

get_dof_axis_and_end_pos(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, axis: pyrosetta.rosetta.numeric.xyzVector_double_t, end_pos: pyrosetta.rosetta.numeric.xyzVector_double_t, type: pyrosetta.rosetta.core.id.DOF_Type) → None

get rotation axis and end_pos for a BondedAtom.

C++: core::kinematics::tree::BondedAtom::get_dof_axis_and_end_pos(class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const enum core::id::DOF_Type) const –> void

get_input_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.Stub

stub used to build this atom

C++: core::kinematics::tree::Atom_::get_input_stub() const –> class core::kinematics::Stub

get_inversion(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) → bool

C++: core::kinematics::tree::BondedAtom::get_inversion() –> bool

get_nonjump_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, i: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

get non-jump atom by its index from the children atoms list

C++: core::kinematics::tree::Atom_::get_nonjump_atom(const unsigned long) const –> class std::shared_ptr<const class core::kinematics::tree::Atom>

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

C++: core::kinematics::tree::Atom::get_self_ptr() –> class std::shared_ptr<class core::kinematics::tree::Atom>

get_self_weak_ptr(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t

C++: core::kinematics::tree::Atom::get_self_weak_ptr() –> class std::weak_ptr<class core::kinematics::tree::Atom>

get_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.Stub

stub centerd at this atom

C++: core::kinematics::tree::Atom_::get_stub() const –> class core::kinematics::Stub

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.core.id.AtomID

Atom identifier

C++: core::kinematics::tree::Atom_::id() const –> const class core::id::AtomID &

2. id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, id_in: pyrosetta.rosetta.core.id.AtomID) -> None

AtomID assignment

C++: core::kinematics::tree::Atom_::id(const class core::id::AtomID &) –> void

input_stub_atom0(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the center of the input stub for refolding this atom

it is its parent

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

input_stub_atom0_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom0’s id

C++: core::kinematics::tree::Atom_::input_stub_atom0_id() const –> const class core::id::AtomID &

input_stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the first atom to construct the input stub for refolding this atom

it is its parent’s stub_atom1, which normally the parent itself

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

input_stub_atom1_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom1’s id

C++: core::kinematics::tree::Atom_::input_stub_atom1_id() const –> const class core::id::AtomID &

input_stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the second atom to construct the input stub for refolding this atom

it is its parent’s stub_atom2, which normally the parent’s parent

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

input_stub_atom2_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom2’s id

C++: core::kinematics::tree::Atom_::input_stub_atom2_id() const –> const class core::id::AtomID &

input_stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the third atom to construct the input stub for refolding this atom

it is either its previous sibling or its parent’s stub_atom3,

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

input_stub_atom3_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom3’s id

C++: core::kinematics::tree::Atom_::input_stub_atom3_id() const –> const class core::id::AtomID &

insert_atom(*args, **kwargs)

Overloaded function.

1. insert_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom) -> None

insert an atom as this atom’s child

C++: core::kinematics::tree::Atom_::insert_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

2. insert_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom, : int) -> None

tries to insert at the position specified by the second argument

C++: core::kinematics::tree::Atom_::insert_atom(class std::shared_ptr<class core::kinematics::tree::Atom>, const int) –> void

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

bonded atom is a jump? of course not!!!

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

jump(*args, **kwargs)

Overloaded function.

1. jump(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) -> pyrosetta.rosetta.core.kinematics.Jump

abort if attempt to get jump for a bonded atom

C++: core::kinematics::tree::BondedAtom::jump() const –> const class core::kinematics::Jump &

2. jump(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, : pyrosetta.rosetta.core.kinematics.Jump) -> None

abort if attempt to set jump for a bonded atom

C++: core::kinematics::tree::BondedAtom::jump(const class core::kinematics::Jump &) –> void

3. jump(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, : pyrosetta.rosetta.core.kinematics.Jump, : pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> None

abort if attempt to set jump for a bonded atom

C++: core::kinematics::tree::BondedAtom::jump(const class core::kinematics::Jump &, class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &) –> void

keep_1st_child_pos(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) → bool

when other atoms are inserted insert after 1st child if available.

–> this enables us to keep a stub of Downstream Jump atoms inside a single residue

C++: core::kinematics::tree::BondedAtom::keep_1st_child_pos() const –> bool

keep_dof_fixed(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, type: pyrosetta.rosetta.core.id.DOF_Type) → bool

whether a DOF for this atom should be fixed?

C++: core::kinematics::tree::BondedAtom::keep_dof_fixed(const enum core::id::DOF_Type) const –> bool

n_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → int

number of children atoms

C++: core::kinematics::tree::Atom_::n_atom() const –> unsigned long

n_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → int

number of the child atoms

C++: core::kinematics::tree::Atom_::n_children() const –> unsigned long

n_nonjump_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → int

number of the non-jump child atoms

C++: core::kinematics::tree::Atom_::n_nonjump_children() const –> unsigned long

next_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

find the child atom after this child in the list

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

parent(*args, **kwargs)

Overloaded function.

1. parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.core.kinematics.tree.Atom

Parent atom pointer

C++: core::kinematics::tree::Atom_::parent() –> class std::shared_ptr<class core::kinematics::tree::Atom>

2. parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, parent_in: pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t) -> None

C++: core::kinematics::tree::Atom_::parent(class std::weak_ptr<class core::kinematics::tree::Atom>) –> void

position(*args, **kwargs)

Overloaded function.

1. position(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Position

C++: core::kinematics::tree::Atom_::position() const –> const class numeric::xyzVector<double> &

2. position(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, position_a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Position assignment

C++: core::kinematics::tree::Atom_::position(const class numeric::xyzVector<double> &) –> void

previous_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

find the child atom before this child in the list

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

previous_sibling(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

routines for navigating the tree

find the sibling atom before itself

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

raw_child_index(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

the atom-index of this child

C++: core::kinematics::tree::Atom_::raw_child_index(const class core::kinematics::tree::Atom *) const –> unsigned long

raw_get_nonjump_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, i: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_get_nonjump_atom(const unsigned long) const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom0(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom0() const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom1() const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom2() const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom3() const –> const class core::kinematics::tree::Atom *

raw_parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_parent() const –> const class core::kinematics::tree::Atom *

raw_previous_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_previous_child(const class core::kinematics::tree::Atom *) const –> const class core::kinematics::tree::Atom *

raw_previous_sibling(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_previous_sibling() const –> const class core::kinematics::tree::Atom *

raw_stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::BondedAtom::raw_stub_atom1() const –> const class core::kinematics::tree::Atom *

raw_stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::BondedAtom::raw_stub_atom2() const –> const class core::kinematics::tree::Atom *

raw_stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::BondedAtom::raw_stub_atom3() const –> const class core::kinematics::tree::Atom *

replace_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, old_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, new_atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

replace the old atom by the new atom in the child atom list

C++: core::kinematics::tree::Atom_::replace_atom(const class std::shared_ptr<class core::kinematics::tree::Atom>, const class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

set_dof(*args, **kwargs)

Overloaded function.

1. set_dof(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, type: pyrosetta.rosetta.core.id.DOF_Type, value: float) -> None

set degrees of freedom (internal coordinates)

C++: core::kinematics::tree::BondedAtom::set_dof(const enum core::id::DOF_Type, const double) –> void

2. set_dof(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, type: pyrosetta.rosetta.core.id.DOF_Type, value: float, changeset: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> None

set degrees of freedom (internal coordinates). For use in

output-sensitive refold subroutine.

C++: core::kinematics::tree::BondedAtom::set_dof(const enum core::id::DOF_Type, const double, class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &) –> void

setup_min_map(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, last_torsion: pyrosetta.rosetta.core.id.DOF_ID, allow_move: pyrosetta.rosetta.core.id.DOF_ID_Map_bool_t, min_map: pyrosetta.rosetta.core.kinematics.MinimizerMapBase) → None

for minimizing,add DOF(PHI,THETA,D) for a BondedAtom into the MinimizerMap

C++: core::kinematics::tree::BondedAtom::setup_min_map(class core::id::DOF_ID &, const class core::id::DOF_ID_Map<bool> &, class core::kinematics::MinimizerMapBase &) const –> void

shallow_clone(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

copy this atom, without connections

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> None

dump out AtomID for this atom, its parent and all its offspring

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

2. show(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, n_level: int) -> None

dump out AtomID for this atom, its parent and all its offspring up to n_level

C++: core::kinematics::tree::Atom_::show(const int &) const –> void

steal_inversion(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, steal_from: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

C++: core::kinematics::tree::BondedAtom::steal_inversion(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

stub_atom1 of a bonded atom it is itself

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

stub_atom1_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

stub atom1 ‘s id

C++: core::kinematics::tree::Atom_::stub_atom1_id() const –> const class core::id::AtomID &

stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

stub_atom2 of a bonded atom it is its parent

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

stub_atom2_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

stub atom2’s id

C++: core::kinematics::tree::Atom_::stub_atom2_id() const –> const class core::id::AtomID &

stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

stub_atom3 of a bonded atom

• if this atom’s parent is a bonded_atom it is this atom’s parent’s parent.

• if this atom’s parent is a jump atom, it is this atom’s first non-jump

sibling or its second non-jump sibling (if it itself is the first) or its first non-jump child (if it does not have any sibling)

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

stub_atom3_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

stub atom3’s id

C++: core::kinematics::tree::Atom_::stub_atom3_id() const –> const class core::id::AtomID &

stub_defined(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → bool

whether a Stub can be defined for this atom

C++: core::kinematics::tree::Atom_::stub_defined() const –> bool

transform_Ax_plus_b_recursive(self: pyrosetta.rosetta.core.kinematics.tree.Atom, A: pyrosetta.rosetta.numeric.xyzMatrix_double_t, b: pyrosetta.rosetta.numeric.xyzVector_double_t, res_change_list: core::kinematics::ResidueCoordinateChangeList) → None

Transform atom and children by linear transformation

C++: core::kinematics::tree::Atom::transform_Ax_plus_b_recursive(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &, class core::kinematics::ResidueCoordinateChangeList &) –> void

update_domain_map(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, current_color: int, biggest_color: int, domain_map: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, dof_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, atom_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t) → None

update domain map

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

update_internal_coords(*args, **kwargs)

Overloaded function.

1. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, stub: pyrosetta.rosetta.core.kinematics.Stub) -> None

2. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, stub: pyrosetta.rosetta.core.kinematics.Stub, recursive: bool) -> None

3. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, recursive: bool) -> None

update_stub(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, stub: pyrosetta.rosetta.core.kinematics.Stub) → None

update the stub without actually updating coordinates

C++: core::kinematics::tree::BondedAtom::update_stub(class core::kinematics::Stub &) const –> void

update_xyz_coords(*args, **kwargs)

Overloaded function.

1. update_xyz_coords(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom) -> None

The atom must retrieve an appropriate stub from its parent; it is the root

of the subtree being refolded. Valid only if this atom is the maximal root of a subtree requiring coordinate updates – if any ancestor of this atom requires a coordinate update, then the Stub this atom generates for itself will be invalid.

C++: core::kinematics::tree::BondedAtom::update_xyz_coords() –> void

2. update_xyz_coords(self: pyrosetta.rosetta.core.kinematics.tree.BondedAtom, stub: pyrosetta.rosetta.core.kinematics.Stub) -> None

update cartesian coordinates for this atom from its input stub and internal cooridnates

C++: core::kinematics::tree::BondedAtom::update_xyz_coords(class core::kinematics::Stub &) –> void

x(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → float

x coordinate

C++: core::kinematics::tree::Atom_::x() const –> const double &

xyz(*args, **kwargs)

Overloaded function.

1. xyz(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Position

C++: core::kinematics::tree::Atom_::xyz() const –> const class numeric::xyzVector<double> &

2. xyz(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, position_a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Position assignment

C++: core::kinematics::tree::Atom_::xyz(const class numeric::xyzVector<double> &) –> void

y(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → float

y coordinate

C++: core::kinematics::tree::Atom_::y() const –> const double &

z(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → float

z coordinate

C++: core::kinematics::tree::Atom_::z() const –> const double &

class pyrosetta.rosetta.core.kinematics.tree.JumpAtom

Bases: Atom_

an atom who are connected to its parent via rigid-body transformation “Jump”

See

append_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

append an atom as this atom’s child

C++: core::kinematics::tree::Atom_::append_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

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

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

atom_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

Atom identifier

C++: core::kinematics::tree::Atom_::atom_id() const –> const class core::id::AtomID &

atom_is_on_path_from_root(self: pyrosetta.rosetta.core.kinematics.tree.Atom, atm: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

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

child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, k: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

get a child atom by index

C++: core::kinematics::tree::Atom_::child(const unsigned long) –> class std::shared_ptr<class core::kinematics::tree::Atom>

child_index(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

the atom-index of this child

C++: core::kinematics::tree::Atom_::child_index(class std::shared_ptr<const class core::kinematics::tree::Atom>) const –> unsigned long

clone(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, parent_in: pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t, atom_pointer: pyrosetta.rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) → pyrosetta.rosetta.core.kinematics.tree.Atom

copy atom with new memory allocation

C++: core::kinematics::tree::Atom_::clone(class std::weak_ptr<class core::kinematics::tree::Atom>, class core::id::AtomID_Map<class std::shared_ptr<class core::kinematics::tree::Atom> > &) const –> class std::shared_ptr<class core::kinematics::tree::Atom>

copy_coords(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, src: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

copy DOFs, xyz’s

C++: core::kinematics::tree::JumpAtom::copy_coords(const class core::kinematics::tree::Atom &) –> void

delete_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom) → None

remove an atom from this atom’s children

C++: core::kinematics::tree::Atom_::delete_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

dfs(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, changeset: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange, res_change_list: pyrosetta.rosetta.core.kinematics.ResidueCoordinateChangeList, start_atom_index: int) → None

Perform a depth-first traversal of the tree that would be effected by

a DOF change from this atom. Stop at atoms that have already been traversed.

C++: core::kinematics::tree::JumpAtom::dfs(class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &, class core::kinematics::ResidueCoordinateChangeList &, const unsigned long) const –> void

dihedral_between_bonded_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child1: pyrosetta.rosetta.core.kinematics.tree.Atom, child2: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

dihedral angle between two bonded children to this atom

C++: core::kinematics::tree::Atom_::dihedral_between_bonded_children(const class core::kinematics::tree::Atom &, const class core::kinematics::tree::Atom &) const –> double

distance(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance to an Atom

C++: core::kinematics::tree::Atom_::distance(const class core::kinematics::tree::Atom &) const –> double

distance_squared(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance squared to an Atom

C++: core::kinematics::tree::Atom_::distance_squared(const class core::kinematics::tree::Atom &) const –> double

dof(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, type: pyrosetta.rosetta.core.id.DOF_Type) → float

get a degree of freedom from jump

C++: core::kinematics::tree::JumpAtom::dof(const enum core::id::DOF_Type) const –> double

downstream(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, atom1: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

whether atom1 is downstream of this atom.

C++: core::kinematics::tree::Atom_::downstream(class std::shared_ptr<const class core::kinematics::tree::Atom>) const –> bool

get_dof_axis_and_end_pos(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, axis: pyrosetta.rosetta.numeric.xyzVector_double_t, end_pos: pyrosetta.rosetta.numeric.xyzVector_double_t, type: pyrosetta.rosetta.core.id.DOF_Type) → None

get rotation axis and end_pos for a JumpAtom.

C++: core::kinematics::tree::JumpAtom::get_dof_axis_and_end_pos(class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const enum core::id::DOF_Type) const –> void

get_input_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.Stub

stub used to build this atom

C++: core::kinematics::tree::Atom_::get_input_stub() const –> class core::kinematics::Stub

get_inversion(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) → Tuple[bool, bool]

C++: core::kinematics::tree::JumpAtom::get_inversion() –> struct std::pair<bool, bool>

get_nonjump_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, i: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

get non-jump atom by its index from the children atoms list

C++: core::kinematics::tree::Atom_::get_nonjump_atom(const unsigned long) const –> class std::shared_ptr<const class core::kinematics::tree::Atom>

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

C++: core::kinematics::tree::Atom::get_self_ptr() –> class std::shared_ptr<class core::kinematics::tree::Atom>

get_self_weak_ptr(self: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t

C++: core::kinematics::tree::Atom::get_self_weak_ptr() –> class std::weak_ptr<class core::kinematics::tree::Atom>

get_stub(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.Stub

stub centerd at this atom

C++: core::kinematics::tree::Atom_::get_stub() const –> class core::kinematics::Stub

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.core.id.AtomID

Atom identifier

C++: core::kinematics::tree::Atom_::id() const –> const class core::id::AtomID &

2. id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, id_in: pyrosetta.rosetta.core.id.AtomID) -> None

AtomID assignment

C++: core::kinematics::tree::Atom_::id(const class core::id::AtomID &) –> void

input_stub_atom0(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the center of the input stub for refolding this atom

it is its parent

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

input_stub_atom0_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom0’s id

C++: core::kinematics::tree::Atom_::input_stub_atom0_id() const –> const class core::id::AtomID &

input_stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the first atom to construct the input stub for refolding this atom

it is its parent’s stub_atom1, which normally the parent itself

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

input_stub_atom1_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom1’s id

C++: core::kinematics::tree::Atom_::input_stub_atom1_id() const –> const class core::id::AtomID &

input_stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the second atom to construct the input stub for refolding this atom

it is its parent’s stub_atom2, which normally the parent’s parent

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

input_stub_atom2_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom2’s id

C++: core::kinematics::tree::Atom_::input_stub_atom2_id() const –> const class core::id::AtomID &

input_stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

the third atom to construct the input stub for refolding this atom

it is either its previous sibling or its parent’s stub_atom3,

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

input_stub_atom3_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

input stub atom3’s id

C++: core::kinematics::tree::Atom_::input_stub_atom3_id() const –> const class core::id::AtomID &

insert_atom(*args, **kwargs)

Overloaded function.

1. insert_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom) -> None

insert an atom as this atom’s child

C++: core::kinematics::tree::Atom_::insert_atom(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

2. insert_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, : pyrosetta.rosetta.core.kinematics.tree.Atom, : int) -> None

tries to insert at the position specified by the second argument

C++: core::kinematics::tree::Atom_::insert_atom(class std::shared_ptr<class core::kinematics::tree::Atom>, const int) –> void

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

a jump atom is a jump? of course yes!!!

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

jump(*args, **kwargs)

Overloaded function.

1. jump(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) -> pyrosetta.rosetta.core.kinematics.Jump

access the jump

C++: core::kinematics::tree::JumpAtom::jump() const –> const class core::kinematics::Jump &

2. jump(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, jump_in: pyrosetta.rosetta.core.kinematics.Jump) -> None

set the jump

C++: core::kinematics::tree::JumpAtom::jump(const class core::kinematics::Jump &) –> void

3. jump(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, jump_in: pyrosetta.rosetta.core.kinematics.Jump, changeset: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> None

set the jump. For use with output-sensitive refold subroutine.

C++: core::kinematics::tree::JumpAtom::jump(const class core::kinematics::Jump &, class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &) –> void

keep_1st_child_pos(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) → bool

when other atoms are inserted insert after 1st child if available.

–> this enables us to keep a stub of Downstream Jump atoms inside a single residue

C++: core::kinematics::tree::JumpAtom::keep_1st_child_pos() const –> bool

keep_dof_fixed(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, type: pyrosetta.rosetta.core.id.DOF_Type) → bool

whether a jump should be fixed in some special cases

C++: core::kinematics::tree::JumpAtom::keep_dof_fixed(const enum core::id::DOF_Type) const –> bool

n_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → int

number of children atoms

C++: core::kinematics::tree::Atom_::n_atom() const –> unsigned long

n_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → int

number of the child atoms

C++: core::kinematics::tree::Atom_::n_children() const –> unsigned long

n_nonjump_children(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → int

number of the non-jump child atoms

C++: core::kinematics::tree::Atom_::n_nonjump_children() const –> unsigned long

next_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

find the child atom after this child in the list

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

parent(*args, **kwargs)

Overloaded function.

1. parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.core.kinematics.tree.Atom

Parent atom pointer

C++: core::kinematics::tree::Atom_::parent() –> class std::shared_ptr<class core::kinematics::tree::Atom>

2. parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, parent_in: pyrosetta.rosetta.std.weak_ptr_core_kinematics_tree_Atom_t) -> None

C++: core::kinematics::tree::Atom_::parent(class std::weak_ptr<class core::kinematics::tree::Atom>) –> void

position(*args, **kwargs)

Overloaded function.

1. position(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Position

C++: core::kinematics::tree::Atom_::position() const –> const class numeric::xyzVector<double> &

2. position(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, position_a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Position assignment

C++: core::kinematics::tree::Atom_::position(const class numeric::xyzVector<double> &) –> void

previous_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

find the child atom before this child in the list

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

previous_sibling(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

routines for navigating the tree

find the sibling atom before itself

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

raw_child_index(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → int

the atom-index of this child

C++: core::kinematics::tree::Atom_::raw_child_index(const class core::kinematics::tree::Atom *) const –> unsigned long

raw_get_nonjump_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, i: int) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_get_nonjump_atom(const unsigned long) const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom0(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom0() const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom1() const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom2() const –> const class core::kinematics::tree::Atom *

raw_input_stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_input_stub_atom3() const –> const class core::kinematics::tree::Atom *

raw_parent(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_parent() const –> const class core::kinematics::tree::Atom *

raw_previous_child(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, child: pyrosetta.rosetta.core.kinematics.tree.Atom) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_previous_child(const class core::kinematics::tree::Atom *) const –> const class core::kinematics::tree::Atom *

raw_previous_sibling(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::Atom_::raw_previous_sibling() const –> const class core::kinematics::tree::Atom *

raw_stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::JumpAtom::raw_stub_atom1() const –> const class core::kinematics::tree::Atom *

raw_stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::JumpAtom::raw_stub_atom2() const –> const class core::kinematics::tree::Atom *

raw_stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

C++: core::kinematics::tree::JumpAtom::raw_stub_atom3() const –> const class core::kinematics::tree::Atom *

replace_atom(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, old_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, new_atom: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

replace the old atom by the new atom in the child atom list

C++: core::kinematics::tree::Atom_::replace_atom(const class std::shared_ptr<class core::kinematics::tree::Atom>, const class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

set_dof(*args, **kwargs)

Overloaded function.

1. set_dof(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, type: pyrosetta.rosetta.core.id.DOF_Type, value: float) -> None

set a degree of freedom for jump

C++: core::kinematics::tree::JumpAtom::set_dof(const enum core::id::DOF_Type, const double) –> void

2. set_dof(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, type: pyrosetta.rosetta.core.id.DOF_Type, value: float, changeset: pyrosetta.rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> None

set degrees of freedom (internal coordinates). For use in

output-sensitive refold subroutine.

C++: core::kinematics::tree::JumpAtom::set_dof(const enum core::id::DOF_Type, const double, class utility::vector1<class core::kinematics::AtomWithDOFChange, class std::allocator<class core::kinematics::AtomWithDOFChange> > &) –> void

setup_min_map(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, last_torsion: pyrosetta.rosetta.core.id.DOF_ID, allow_move: pyrosetta.rosetta.core.id.DOF_ID_Map_bool_t, min_map: pyrosetta.rosetta.core.kinematics.MinimizerMapBase) → None

for minimizing, add DOF(RB) for a JumpAtom into the MinimizerMap

C++: core::kinematics::tree::JumpAtom::setup_min_map(class core::id::DOF_ID &, const class core::id::DOF_ID_Map<bool> &, class core::kinematics::MinimizerMapBase &) const –> void

shallow_clone(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

copy this atom, without connections

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> None

dump out AtomID for this atom, its parent and all its offspring

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

2. show(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, n_level: int) -> None

dump out AtomID for this atom, its parent and all its offspring up to n_level

C++: core::kinematics::tree::Atom_::show(const int &) const –> void

steal_inversion(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, steal_from: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

C++: core::kinematics::tree::JumpAtom::steal_inversion(class std::shared_ptr<class core::kinematics::tree::Atom>) –> void

stub_atom1(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

stub_atom1 of a jump-atom it is itself if a stub can be defined for it. Otherwise it is parent

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

stub_atom1_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

stub atom1 ‘s id

C++: core::kinematics::tree::Atom_::stub_atom1_id() const –> const class core::id::AtomID &

stub_atom2(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

stub_atom2 of a jump-atom it is its first bonded child if a stub can be defined for it. Otherwise

it is parent’s stub_atom2.

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

stub_atom2_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

stub atom2’s id

C++: core::kinematics::tree::Atom_::stub_atom2_id() const –> const class core::id::AtomID &

stub_atom3(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) → pyrosetta.rosetta.core.kinematics.tree.Atom

stub_atom3 of a jump atom it is its child’s child or its second child if a stub can be defined for it,

otherwise it is its parent’s stub_atom3

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

stub_atom3_id(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → pyrosetta.rosetta.core.id.AtomID

stub atom3’s id

C++: core::kinematics::tree::Atom_::stub_atom3_id() const –> const class core::id::AtomID &

stub_defined(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → bool

whether a Stub can be defined for this atom

C++: core::kinematics::tree::Atom_::stub_defined() const –> bool

transform_Ax_plus_b_recursive(self: pyrosetta.rosetta.core.kinematics.tree.Atom, A: pyrosetta.rosetta.numeric.xyzMatrix_double_t, b: pyrosetta.rosetta.numeric.xyzVector_double_t, res_change_list: core::kinematics::ResidueCoordinateChangeList) → None

Transform atom and children by linear transformation

C++: core::kinematics::tree::Atom::transform_Ax_plus_b_recursive(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &, class core::kinematics::ResidueCoordinateChangeList &) –> void

update_domain_map(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, current_color: int, biggest_color: int, domain_map: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, dof_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, atom_moved: pyrosetta.rosetta.core.id.AtomID_Map_bool_t) → None

update domain map

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

update_internal_coords(*args, **kwargs)

Overloaded function.

1. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, stub: pyrosetta.rosetta.core.kinematics.Stub) -> None

2. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, stub: pyrosetta.rosetta.core.kinematics.Stub, recursive: bool) -> None

3. update_internal_coords(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, recursive: bool) -> None

update_stub(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, : pyrosetta.rosetta.core.kinematics.Stub) → None

update the stub without actually updating coordinates

C++: core::kinematics::tree::JumpAtom::update_stub(class core::kinematics::Stub &) const –> void

update_xyz_coords(*args, **kwargs)

Overloaded function.

1. update_xyz_coords(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom) -> None

The atom must retrieve an appropriate stub from its parent; it is the root

of the subtree being refolded. Valid only if this atom is the maximal root of a subtree requiring coordinate updates – if any ancestor of this atom requires a coordinate update, then the Stub this atom generates for itself will be invalid.

C++: core::kinematics::tree::JumpAtom::update_xyz_coords() –> void

2. update_xyz_coords(self: pyrosetta.rosetta.core.kinematics.tree.JumpAtom, stub: pyrosetta.rosetta.core.kinematics.Stub) -> None

update this atom’s xyz position

C++: core::kinematics::tree::JumpAtom::update_xyz_coords(class core::kinematics::Stub &) –> void

x(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → float

x coordinate

C++: core::kinematics::tree::Atom_::x() const –> const double &

xyz(*args, **kwargs)

Overloaded function.

1. xyz(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Position

C++: core::kinematics::tree::Atom_::xyz() const –> const class numeric::xyzVector<double> &

2. xyz(self: pyrosetta.rosetta.core.kinematics.tree.Atom_, position_a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Position assignment

C++: core::kinematics::tree::Atom_::xyz(const class numeric::xyzVector<double> &) –> void

y(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → float

y coordinate

C++: core::kinematics::tree::Atom_::y() const –> const double &

z(self: pyrosetta.rosetta.core.kinematics.tree.Atom_) → float

z coordinate

C++: core::kinematics::tree::Atom_::z() const –> const double &

pyrosetta.rosetta.core.kinematics.tree.distance(atom1: pyrosetta.rosetta.core.kinematics.tree.Atom, atom2: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance between two Atoms

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

pyrosetta.rosetta.core.kinematics.tree.distance_squared(atom1: pyrosetta.rosetta.core.kinematics.tree.Atom, atom2: pyrosetta.rosetta.core.kinematics.tree.Atom) → float

Distance squared between two Atoms

C++: core::kinematics::tree::distance_squared(const class core::kinematics::tree::Atom &, const class core::kinematics::tree::Atom &) –> double

pyrosetta.rosetta.core.kinematics.tree.is_collinear(atom1: pyrosetta.rosetta.core.kinematics.tree.Atom, atom2: pyrosetta.rosetta.core.kinematics.tree.Atom, atom3: pyrosetta.rosetta.core.kinematics.tree.Atom) → bool

Check collinearity of three atoms

C++: core::kinematics::tree::is_collinear(const class core::kinematics::tree::Atom &, const class core::kinematics::tree::Atom &, const class core::kinematics::tree::Atom &) –> bool