| | |
- builtins.object
-
- Atom
-
- Atom_
-
- BondedAtom
- JumpAtom
class Atom(builtins.object) |
| |
Kinematics Atom interface class
|
| |
Methods defined here:
- __init__(self, /, *args, **kwargs)
- Initialize self. See help(type(self)) for accurate signature.
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- append_atom(...) from builtins.PyCapsule
- append_atom(self : rosetta.core.kinematics.tree.Atom, : rosetta.core.kinematics.tree.Atom) -> NoneType
- atom_id(...) from builtins.PyCapsule
- atom_id(rosetta.core.kinematics.tree.Atom) -> rosetta.core.id.AtomID
Atom identifier
- atom_is_on_path_from_root(...) from builtins.PyCapsule
- atom_is_on_path_from_root(self : rosetta.core.kinematics.tree.Atom, atm : rosetta.core.kinematics.tree.Atom) -> bool
- atoms_begin(...) from builtins.PyCapsule
- atoms_begin(*args, **kwargs)
Overloaded function.
1. atoms_begin(rosetta.core.kinematics.tree.Atom) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom> const*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
////////////////////////////////////////////////////////////////////////
2. atoms_begin(rosetta.core.kinematics.tree.Atom) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom>*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
- atoms_end(...) from builtins.PyCapsule
- atoms_end(*args, **kwargs)
Overloaded function.
1. atoms_end(rosetta.core.kinematics.tree.Atom) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom> const*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
2. atoms_end(rosetta.core.kinematics.tree.Atom) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom>*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
- child(...) from builtins.PyCapsule
- child(*args, **kwargs)
Overloaded function.
1. child(self : rosetta.core.kinematics.tree.Atom, k : int) -> rosetta.core.kinematics.tree.Atom
2. child(self : rosetta.core.kinematics.tree.Atom, k : int) -> rosetta.core.kinematics.tree.Atom
- child_index(...) from builtins.PyCapsule
- child_index(self : rosetta.core.kinematics.tree.Atom, child : rosetta.core.kinematics.tree.Atom) -> int
the atom-index of this child
- clone(...) from builtins.PyCapsule
- clone(self : rosetta.core.kinematics.tree.Atom, parent_in : rosetta.std.weak_ptr_core_kinematics_tree_Atom_t, atom_pointer : rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) -> rosetta.core.kinematics.tree.Atom
copy atom with new memory allocation
- copy_coords(...) from builtins.PyCapsule
- copy_coords(self : rosetta.core.kinematics.tree.Atom, src : rosetta.core.kinematics.tree.Atom) -> NoneType
////////////////////////////////////////////////////////////////////////
copy DOFs and xyz coords from src Atom
- delete_atom(...) from builtins.PyCapsule
- delete_atom(self : rosetta.core.kinematics.tree.Atom, : rosetta.core.kinematics.tree.Atom) -> NoneType
- dfs(...) from builtins.PyCapsule
- dfs(self : rosetta.core.kinematics.tree.Atom, changeset : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange, res_change_list : core::kinematics::ResidueCoordinateChangeList, start_atom_index : int) -> NoneType
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.
- dihedral_between_bonded_children(...) from builtins.PyCapsule
- dihedral_between_bonded_children(self : rosetta.core.kinematics.tree.Atom, child1 : rosetta.core.kinematics.tree.Atom, child2 : rosetta.core.kinematics.tree.Atom) -> float
dihedral angle between two bonded children to this atom
- distance(...) from builtins.PyCapsule
- distance(self : rosetta.core.kinematics.tree.Atom, atom : rosetta.core.kinematics.tree.Atom) -> float
Distance to an Atom
- distance_squared(...) from builtins.PyCapsule
- distance_squared(self : rosetta.core.kinematics.tree.Atom, atom : rosetta.core.kinematics.tree.Atom) -> float
Distance squared to an Atom
- dof(...) from builtins.PyCapsule
- dof(self : rosetta.core.kinematics.tree.Atom, type : rosetta.core.id.DOF_Type) -> float
get dof
- downstream(...) from builtins.PyCapsule
- downstream(self : rosetta.core.kinematics.tree.Atom, atom1 : rosetta.core.kinematics.tree.Atom) -> bool
- get_dof_axis_and_end_pos(...) from builtins.PyCapsule
- get_dof_axis_and_end_pos(self : rosetta.core.kinematics.tree.Atom, axis : rosetta.numeric.xyzVector_double_t, end_pos : rosetta.numeric.xyzVector_double_t, type : rosetta.core.id.DOF_Type) -> NoneType
- get_input_stub(...) from builtins.PyCapsule
- get_input_stub(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.Stub
- get_nonjump_atom(...) from builtins.PyCapsule
- get_nonjump_atom(self : rosetta.core.kinematics.tree.Atom, i : int) -> rosetta.core.kinematics.tree.Atom
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
2. get_self_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- get_self_weak_ptr(...) from builtins.PyCapsule
- get_self_weak_ptr(*args, **kwargs)
Overloaded function.
1. get_self_weak_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.std.weak_ptr_const_core_kinematics_tree_Atom_t
2. get_self_weak_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.std.weak_ptr_core_kinematics_tree_Atom_t
- get_stub(...) from builtins.PyCapsule
- get_stub(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.Stub
Get stub information
- id(...) from builtins.PyCapsule
- id(*args, **kwargs)
Overloaded function.
1. id(rosetta.core.kinematics.tree.Atom) -> rosetta.core.id.AtomID
Atom identifier
2. id(self : rosetta.core.kinematics.tree.Atom, id_in : rosetta.core.id.AtomID) -> NoneType
AtomID assignment
- input_stub_atom0(...) from builtins.PyCapsule
- input_stub_atom0(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- input_stub_atom0_id(...) from builtins.PyCapsule
- input_stub_atom0_id(rosetta.core.kinematics.tree.Atom) -> rosetta.core.id.AtomID
- input_stub_atom1(...) from builtins.PyCapsule
- input_stub_atom1(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- input_stub_atom1_id(...) from builtins.PyCapsule
- input_stub_atom1_id(rosetta.core.kinematics.tree.Atom) -> rosetta.core.id.AtomID
- input_stub_atom2(...) from builtins.PyCapsule
- input_stub_atom2(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- input_stub_atom2_id(...) from builtins.PyCapsule
- input_stub_atom2_id(rosetta.core.kinematics.tree.Atom) -> rosetta.core.id.AtomID
- input_stub_atom3(...) from builtins.PyCapsule
- input_stub_atom3(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- input_stub_atom3_id(...) from builtins.PyCapsule
- input_stub_atom3_id(rosetta.core.kinematics.tree.Atom) -> rosetta.core.id.AtomID
- insert_atom(...) from builtins.PyCapsule
- insert_atom(*args, **kwargs)
Overloaded function.
1. insert_atom(self : rosetta.core.kinematics.tree.Atom, : rosetta.core.kinematics.tree.Atom) -> NoneType
2. insert_atom(self : rosetta.core.kinematics.tree.Atom, : rosetta.core.kinematics.tree.Atom, : int) -> NoneType
- is_jump(...) from builtins.PyCapsule
- is_jump(rosetta.core.kinematics.tree.Atom) -> bool
atom is a jump atom?
- jump(...) from builtins.PyCapsule
- jump(*args, **kwargs)
Overloaded function.
1. jump(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.Jump
get Jump
2. jump(self : rosetta.core.kinematics.tree.Atom, jump_in : rosetta.core.kinematics.Jump) -> NoneType
set Jump
3. jump(self : rosetta.core.kinematics.tree.Atom, jump_in : rosetta.core.kinematics.Jump, set : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> NoneType
set Jump -- for use in output-sensitive refolding
- keep_1st_child_pos(...) from builtins.PyCapsule
- keep_1st_child_pos(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
- keep_dof_fixed(...) from builtins.PyCapsule
- keep_dof_fixed(self : rosetta.core.kinematics.tree.Atom, : 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
- n_atom(...) from builtins.PyCapsule
- n_atom(rosetta.core.kinematics.tree.Atom) -> int
- n_children(...) from builtins.PyCapsule
- n_children(rosetta.core.kinematics.tree.Atom) -> int
- n_nonjump_children(...) from builtins.PyCapsule
- n_nonjump_children(rosetta.core.kinematics.tree.Atom) -> int
- next_child(...) from builtins.PyCapsule
- next_child(self : rosetta.core.kinematics.tree.Atom, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- parent(...) from builtins.PyCapsule
- parent(*args, **kwargs)
Overloaded function.
1. parent(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Parent atom pointer, NULL for root atom
2. parent(self : rosetta.core.kinematics.tree.Atom, parent_in : rosetta.std.weak_ptr_core_kinematics_tree_Atom_t) -> NoneType
parent assignment
3. parent(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Parent atom pointer, NULL for root atom
- position(...) from builtins.PyCapsule
- position(*args, **kwargs)
Overloaded function.
1. position(rosetta.core.kinematics.tree.Atom) -> rosetta.numeric.xyzVector_double_t
Position
2. position(self : rosetta.core.kinematics.tree.Atom, position_a : rosetta.numeric.xyzVector_double_t) -> NoneType
Position assignment
- previous_child(...) from builtins.PyCapsule
- previous_child(self : rosetta.core.kinematics.tree.Atom, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- previous_sibling(...) from builtins.PyCapsule
- previous_sibling(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- raw_child_index(...) from builtins.PyCapsule
- raw_child_index(self : rosetta.core.kinematics.tree.Atom, child : rosetta.core.kinematics.tree.Atom) -> int
the atom-index of this child
- raw_get_nonjump_atom(...) from builtins.PyCapsule
- raw_get_nonjump_atom(self : rosetta.core.kinematics.tree.Atom, i : int) -> 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.
- raw_input_stub_atom0(...) from builtins.PyCapsule
- raw_input_stub_atom0(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the 0th input stub atom;
- raw_input_stub_atom1(...) from builtins.PyCapsule
- raw_input_stub_atom1(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the 1st input stub atom;
- raw_input_stub_atom2(...) from builtins.PyCapsule
- raw_input_stub_atom2(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the 2nd input stub atom;
- raw_input_stub_atom3(...) from builtins.PyCapsule
- raw_input_stub_atom3(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the 3rd input stub atom;
- raw_parent(...) from builtins.PyCapsule
- raw_parent(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the parent atom pointer
- raw_previous_child(...) from builtins.PyCapsule
- raw_previous_child(self : rosetta.core.kinematics.tree.Atom, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the previous child pointer;
- raw_previous_sibling(...) from builtins.PyCapsule
- raw_previous_sibling(rosetta.core.kinematics.tree.Atom) -> 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.
- raw_stub_atom1(...) from builtins.PyCapsule
- raw_stub_atom1(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the fist stub atom
- raw_stub_atom2(...) from builtins.PyCapsule
- raw_stub_atom2(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the second stub atom
- raw_stub_atom3(...) from builtins.PyCapsule
- raw_stub_atom3(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the third stub atom
- replace_atom(...) from builtins.PyCapsule
- replace_atom(self : rosetta.core.kinematics.tree.Atom, old_atom : rosetta.core.kinematics.tree.Atom, new_atom : rosetta.core.kinematics.tree.Atom) -> NoneType
- set_dof(...) from builtins.PyCapsule
- set_dof(*args, **kwargs)
Overloaded function.
1. set_dof(self : rosetta.core.kinematics.tree.Atom, type : rosetta.core.id.DOF_Type, value : float) -> NoneType
set dof, use "set_" syntax since we have multiple dof's
2. set_dof(self : rosetta.core.kinematics.tree.Atom, type : rosetta.core.id.DOF_Type, value : float, set : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> NoneType
set dof, use "set_" syntax since we have multiple dof's -- for use in output-sensitive refold routine
- setup_min_map(...) from builtins.PyCapsule
- setup_min_map(self : rosetta.core.kinematics.tree.Atom, last_torsion : rosetta.core.id.DOF_ID, move_map : rosetta.core.id.DOF_ID_Map_bool_t, min_map : core::kinematics::MinimizerMapBase) -> NoneType
////////////////////////////////////////////////////////////////////////
- show(...) from builtins.PyCapsule
- show(*args, **kwargs)
Overloaded function.
1. show(rosetta.core.kinematics.tree.Atom) -> NoneType
dump out AtomID for this atom, its parent and all its offspring
2. show(self : rosetta.core.kinematics.tree.Atom, : int) -> NoneType
dump out AtomID for this atom, its parent and all its offspring up to n_level
- steal_inversion(...) from builtins.PyCapsule
- steal_inversion(self : rosetta.core.kinematics.tree.Atom, : rosetta.core.kinematics.tree.Atom) -> NoneType
- stub_atom1(...) from builtins.PyCapsule
- stub_atom1(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- stub_atom1_id(...) from builtins.PyCapsule
- stub_atom1_id(rosetta.core.kinematics.tree.Atom) -> rosetta.core.id.AtomID
- stub_atom2(...) from builtins.PyCapsule
- stub_atom2(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- stub_atom2_id(...) from builtins.PyCapsule
- stub_atom2_id(rosetta.core.kinematics.tree.Atom) -> rosetta.core.id.AtomID
- stub_atom3(...) from builtins.PyCapsule
- stub_atom3(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- stub_atom3_id(...) from builtins.PyCapsule
- stub_atom3_id(rosetta.core.kinematics.tree.Atom) -> rosetta.core.id.AtomID
- stub_defined(...) from builtins.PyCapsule
- stub_defined(rosetta.core.kinematics.tree.Atom) -> bool
- transform_Ax_plus_b_recursive(...) from builtins.PyCapsule
- transform_Ax_plus_b_recursive(self : rosetta.core.kinematics.tree.Atom, A : rosetta.numeric.xyzMatrix_double_t, b : rosetta.numeric.xyzVector_double_t, res_change_list : core::kinematics::ResidueCoordinateChangeList) -> NoneType
Transform atom and children by linear transformation
- update_domain_map(...) from builtins.PyCapsule
- update_domain_map(self : rosetta.core.kinematics.tree.Atom, current_color : int, biggest_color : int, domain_map : ObjexxFCL::FArray1D<int>, dof_moved : rosetta.core.id.AtomID_Map_bool_t, atom_moved : rosetta.core.id.AtomID_Map_bool_t) -> NoneType
////////////////////////////////////////////////////////////////////////
- update_internal_coords(...) from builtins.PyCapsule
- update_internal_coords(*args, **kwargs)
Overloaded function.
1. update_internal_coords(self : rosetta.core.kinematics.tree.Atom, stub : rosetta.core.kinematics.Stub) -> NoneType
update internal coords from stub and xyz coords
2. update_internal_coords(self : rosetta.core.kinematics.tree.Atom, stub : rosetta.core.kinematics.Stub, recursive : bool) -> NoneType
update internal coords from stub and xyz coords
3. update_internal_coords(self : rosetta.core.kinematics.tree.Atom, recursive : bool) -> NoneType
calculate my input_stub from the current xyz's and use that input_stub to update my torsions
- update_stub(...) from builtins.PyCapsule
- update_stub(self : rosetta.core.kinematics.tree.Atom, stub : rosetta.core.kinematics.Stub) -> NoneType
update the stub without actually updating coordinates
- update_xyz_coords(...) from builtins.PyCapsule
- update_xyz_coords(*args, **kwargs)
Overloaded function.
1. update_xyz_coords(rosetta.core.kinematics.tree.Atom) -> NoneType
The atom must retrieve an appropriate stub from its parent; it is the root
of the subtree being refolded
2. update_xyz_coords(self : rosetta.core.kinematics.tree.Atom, stub : rosetta.core.kinematics.Stub) -> NoneType
update xyz coords from stub and internal coords and
- x(...) from builtins.PyCapsule
- x(rosetta.core.kinematics.tree.Atom) -> float
x coordinate
- xyz(...) from builtins.PyCapsule
- xyz(*args, **kwargs)
Overloaded function.
1. xyz(rosetta.core.kinematics.tree.Atom) -> rosetta.numeric.xyzVector_double_t
Position
2. xyz(self : rosetta.core.kinematics.tree.Atom, position_a : rosetta.numeric.xyzVector_double_t) -> NoneType
Position assignment
- y(...) from builtins.PyCapsule
- y(rosetta.core.kinematics.tree.Atom) -> float
y coordinate
- z(...) from builtins.PyCapsule
- z(rosetta.core.kinematics.tree.Atom) -> float
z coordinate
|
class Atom_(Atom) |
| |
Kinematics Atom abstract base class
|
| |
- Method resolution order:
- Atom_
- Atom
- builtins.object
Methods defined here:
- __init__(self, /, *args, **kwargs)
- Initialize self. See help(type(self)) for accurate signature.
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- append_atom(...) from builtins.PyCapsule
- append_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom) -> NoneType
append an atom as this atom's child
- atom_id(...) from builtins.PyCapsule
- atom_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
Atom identifier
- atoms_begin(...) from builtins.PyCapsule
- atoms_begin(*args, **kwargs)
Overloaded function.
1. atoms_begin(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom> const*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
starting const iterator of the children atom list
2. atoms_begin(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom>*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
starting iterator of the children atom list
- atoms_end(...) from builtins.PyCapsule
- atoms_end(*args, **kwargs)
Overloaded function.
1. atoms_end(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom> const*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
ending const iterator of the children atom list
2. atoms_end(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom>*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
ending iterator of the children atom list
- child(...) from builtins.PyCapsule
- child(*args, **kwargs)
Overloaded function.
1. child(self : rosetta.core.kinematics.tree.Atom_, k : int) -> rosetta.core.kinematics.tree.Atom
get a child atom by index (const method)
2. child(self : rosetta.core.kinematics.tree.Atom_, k : int) -> rosetta.core.kinematics.tree.Atom
get a child atom by index
- child_index(...) from builtins.PyCapsule
- child_index(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> int
the atom-index of this child
- delete_atom(...) from builtins.PyCapsule
- delete_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom) -> NoneType
remove an atom from this atom's children
- dfs(...) from builtins.PyCapsule
- dfs(self : rosetta.core.kinematics.tree.Atom_, changeset : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange, res_change_list : rosetta.core.kinematics.ResidueCoordinateChangeList, start_atom_index : int) -> NoneType
base class implementation that traverses the subtree routed at this node
in the depth-first traversal of the atoms requiring coordinate updates.
- dihedral_between_bonded_children(...) from builtins.PyCapsule
- dihedral_between_bonded_children(self : rosetta.core.kinematics.tree.Atom_, child1 : rosetta.core.kinematics.tree.Atom, child2 : rosetta.core.kinematics.tree.Atom) -> float
dihedral angle between two bonded children to this atom
- distance(...) from builtins.PyCapsule
- distance(self : rosetta.core.kinematics.tree.Atom_, atom : rosetta.core.kinematics.tree.Atom) -> float
Distance to an Atom
- distance_squared(...) from builtins.PyCapsule
- distance_squared(self : rosetta.core.kinematics.tree.Atom_, atom : rosetta.core.kinematics.tree.Atom) -> float
Distance squared to an Atom
- downstream(...) from builtins.PyCapsule
- downstream(self : rosetta.core.kinematics.tree.Atom_, atom1 : rosetta.core.kinematics.tree.Atom) -> bool
whether atom1 is downstream of this atom.
- get_input_stub(...) from builtins.PyCapsule
- get_input_stub(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.Stub
stub used to build this atom
- get_nonjump_atom(...) from builtins.PyCapsule
- get_nonjump_atom(self : rosetta.core.kinematics.tree.Atom_, i : int) -> rosetta.core.kinematics.tree.Atom
get non-jump atom by its index from the children atoms list
- get_stub(...) from builtins.PyCapsule
- get_stub(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.Stub
stub centerd at this atom
- id(...) from builtins.PyCapsule
- id(*args, **kwargs)
Overloaded function.
1. id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
Atom identifier
2. id(self : rosetta.core.kinematics.tree.Atom_, id_in : rosetta.core.id.AtomID) -> NoneType
AtomID assignment
- input_stub_atom0(...) from builtins.PyCapsule
- input_stub_atom0(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
the center of the input stub for refolding this atom
it is its parent
- input_stub_atom0_id(...) from builtins.PyCapsule
- input_stub_atom0_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom0's id
- input_stub_atom1(...) from builtins.PyCapsule
- input_stub_atom1(rosetta.core.kinematics.tree.Atom_) -> 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
- input_stub_atom1_id(...) from builtins.PyCapsule
- input_stub_atom1_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom1's id
- input_stub_atom2(...) from builtins.PyCapsule
- input_stub_atom2(rosetta.core.kinematics.tree.Atom_) -> 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
- input_stub_atom2_id(...) from builtins.PyCapsule
- input_stub_atom2_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom2's id
- input_stub_atom3(...) from builtins.PyCapsule
- input_stub_atom3(rosetta.core.kinematics.tree.Atom_) -> 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,
- input_stub_atom3_id(...) from builtins.PyCapsule
- input_stub_atom3_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom3's id
- insert_atom(...) from builtins.PyCapsule
- insert_atom(*args, **kwargs)
Overloaded function.
1. insert_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom) -> NoneType
insert an atom as this atom's child
2. insert_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom, : int) -> NoneType
tries to insert at the position specified by the second argument
- keep_dof_fixed(...) from builtins.PyCapsule
- keep_dof_fixed(self : rosetta.core.kinematics.tree.Atom_, : 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
- n_atom(...) from builtins.PyCapsule
- n_atom(rosetta.core.kinematics.tree.Atom_) -> int
number of children atoms
- n_children(...) from builtins.PyCapsule
- n_children(rosetta.core.kinematics.tree.Atom_) -> int
number of the child atoms
- n_nonjump_children(...) from builtins.PyCapsule
- n_nonjump_children(rosetta.core.kinematics.tree.Atom_) -> int
number of the non-jump child atoms
- next_child(...) from builtins.PyCapsule
- next_child(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
find the child atom after this child in the list
- parent(...) from builtins.PyCapsule
- parent(*args, **kwargs)
Overloaded function.
1. parent(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
Parent atom pointer
2. parent(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
Parent atom pointer
3. parent(self : rosetta.core.kinematics.tree.Atom_, parent_in : rosetta.std.weak_ptr_core_kinematics_tree_Atom_t) -> NoneType
- position(...) from builtins.PyCapsule
- position(*args, **kwargs)
Overloaded function.
1. position(rosetta.core.kinematics.tree.Atom_) -> rosetta.numeric.xyzVector_double_t
Position
2. position(self : rosetta.core.kinematics.tree.Atom_, position_a : rosetta.numeric.xyzVector_double_t) -> NoneType
Position assignment
- previous_child(...) from builtins.PyCapsule
- previous_child(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
find the child atom before this child in the list
- previous_sibling(...) from builtins.PyCapsule
- previous_sibling(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
routines for navigating the tree
find the sibling atom before itself
- raw_child_index(...) from builtins.PyCapsule
- raw_child_index(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> int
the atom-index of this child
- raw_get_nonjump_atom(...) from builtins.PyCapsule
- raw_get_nonjump_atom(self : rosetta.core.kinematics.tree.Atom_, i : int) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom0(...) from builtins.PyCapsule
- raw_input_stub_atom0(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom1(...) from builtins.PyCapsule
- raw_input_stub_atom1(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom2(...) from builtins.PyCapsule
- raw_input_stub_atom2(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom3(...) from builtins.PyCapsule
- raw_input_stub_atom3(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_parent(...) from builtins.PyCapsule
- raw_parent(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_previous_child(...) from builtins.PyCapsule
- raw_previous_child(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- raw_previous_sibling(...) from builtins.PyCapsule
- raw_previous_sibling(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- replace_atom(...) from builtins.PyCapsule
- replace_atom(self : rosetta.core.kinematics.tree.Atom_, old_atom : rosetta.core.kinematics.tree.Atom, new_atom : rosetta.core.kinematics.tree.Atom) -> NoneType
replace the old atom by the new atom in the child atom list
- show(...) from builtins.PyCapsule
- show(*args, **kwargs)
Overloaded function.
1. show(rosetta.core.kinematics.tree.Atom_) -> NoneType
dump out AtomID for this atom, its parent and all its offspring
2. show(self : rosetta.core.kinematics.tree.Atom_, n_level : int) -> NoneType
dump out AtomID for this atom, its parent and all its offspring up to n_level
- stub_atom1_id(...) from builtins.PyCapsule
- stub_atom1_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
stub atom1 's id
- stub_atom2_id(...) from builtins.PyCapsule
- stub_atom2_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
stub atom2's id
- stub_atom3_id(...) from builtins.PyCapsule
- stub_atom3_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
stub atom3's id
- stub_defined(...) from builtins.PyCapsule
- stub_defined(rosetta.core.kinematics.tree.Atom_) -> bool
whether a Stub can be defined for this atom
- update_domain_map(...) from builtins.PyCapsule
- update_domain_map(self : rosetta.core.kinematics.tree.Atom_, current_color : int, biggest_color : int, domain_map : ObjexxFCL::FArray1D<int>, dof_moved : rosetta.core.id.AtomID_Map_bool_t, atom_moved : rosetta.core.id.AtomID_Map_bool_t) -> NoneType
////////////////////////////////////////////////////////////////////////
update domain map
- update_internal_coords(...) from builtins.PyCapsule
- update_internal_coords(self : rosetta.core.kinematics.tree.Atom_, recursive : bool) -> NoneType
update internal coords of this atom and its offspring atoms (if recursive)
- update_xyz_coords(...) from builtins.PyCapsule
- update_xyz_coords(rosetta.core.kinematics.tree.Atom_) -> NoneType
update xyz position of this atom and its offspring atoms
- x(...) from builtins.PyCapsule
- x(rosetta.core.kinematics.tree.Atom_) -> float
x coordinate
- xyz(...) from builtins.PyCapsule
- xyz(*args, **kwargs)
Overloaded function.
1. xyz(rosetta.core.kinematics.tree.Atom_) -> rosetta.numeric.xyzVector_double_t
Position
2. xyz(self : rosetta.core.kinematics.tree.Atom_, position_a : rosetta.numeric.xyzVector_double_t) -> NoneType
Position assignment
- y(...) from builtins.PyCapsule
- y(rosetta.core.kinematics.tree.Atom_) -> float
y coordinate
- z(...) from builtins.PyCapsule
- z(rosetta.core.kinematics.tree.Atom_) -> float
z coordinate
Methods inherited from Atom:
- atom_is_on_path_from_root(...) from builtins.PyCapsule
- atom_is_on_path_from_root(self : rosetta.core.kinematics.tree.Atom, atm : rosetta.core.kinematics.tree.Atom) -> bool
- clone(...) from builtins.PyCapsule
- clone(self : rosetta.core.kinematics.tree.Atom, parent_in : rosetta.std.weak_ptr_core_kinematics_tree_Atom_t, atom_pointer : rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) -> rosetta.core.kinematics.tree.Atom
copy atom with new memory allocation
- copy_coords(...) from builtins.PyCapsule
- copy_coords(self : rosetta.core.kinematics.tree.Atom, src : rosetta.core.kinematics.tree.Atom) -> NoneType
////////////////////////////////////////////////////////////////////////
copy DOFs and xyz coords from src Atom
- dof(...) from builtins.PyCapsule
- dof(self : rosetta.core.kinematics.tree.Atom, type : rosetta.core.id.DOF_Type) -> float
get dof
- get_dof_axis_and_end_pos(...) from builtins.PyCapsule
- get_dof_axis_and_end_pos(self : rosetta.core.kinematics.tree.Atom, axis : rosetta.numeric.xyzVector_double_t, end_pos : rosetta.numeric.xyzVector_double_t, type : rosetta.core.id.DOF_Type) -> NoneType
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
2. get_self_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- get_self_weak_ptr(...) from builtins.PyCapsule
- get_self_weak_ptr(*args, **kwargs)
Overloaded function.
1. get_self_weak_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.std.weak_ptr_const_core_kinematics_tree_Atom_t
2. get_self_weak_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.std.weak_ptr_core_kinematics_tree_Atom_t
- is_jump(...) from builtins.PyCapsule
- is_jump(rosetta.core.kinematics.tree.Atom) -> bool
atom is a jump atom?
- jump(...) from builtins.PyCapsule
- jump(*args, **kwargs)
Overloaded function.
1. jump(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.Jump
get Jump
2. jump(self : rosetta.core.kinematics.tree.Atom, jump_in : rosetta.core.kinematics.Jump) -> NoneType
set Jump
3. jump(self : rosetta.core.kinematics.tree.Atom, jump_in : rosetta.core.kinematics.Jump, set : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> NoneType
set Jump -- for use in output-sensitive refolding
- keep_1st_child_pos(...) from builtins.PyCapsule
- keep_1st_child_pos(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
- raw_stub_atom1(...) from builtins.PyCapsule
- raw_stub_atom1(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the fist stub atom
- raw_stub_atom2(...) from builtins.PyCapsule
- raw_stub_atom2(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the second stub atom
- raw_stub_atom3(...) from builtins.PyCapsule
- raw_stub_atom3(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
Rapid (increment-of-reference-count-avoiding) access to the third stub atom
- set_dof(...) from builtins.PyCapsule
- set_dof(*args, **kwargs)
Overloaded function.
1. set_dof(self : rosetta.core.kinematics.tree.Atom, type : rosetta.core.id.DOF_Type, value : float) -> NoneType
set dof, use "set_" syntax since we have multiple dof's
2. set_dof(self : rosetta.core.kinematics.tree.Atom, type : rosetta.core.id.DOF_Type, value : float, set : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> NoneType
set dof, use "set_" syntax since we have multiple dof's -- for use in output-sensitive refold routine
- setup_min_map(...) from builtins.PyCapsule
- setup_min_map(self : rosetta.core.kinematics.tree.Atom, last_torsion : rosetta.core.id.DOF_ID, move_map : rosetta.core.id.DOF_ID_Map_bool_t, min_map : core::kinematics::MinimizerMapBase) -> NoneType
////////////////////////////////////////////////////////////////////////
- steal_inversion(...) from builtins.PyCapsule
- steal_inversion(self : rosetta.core.kinematics.tree.Atom, : rosetta.core.kinematics.tree.Atom) -> NoneType
- stub_atom1(...) from builtins.PyCapsule
- stub_atom1(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- stub_atom2(...) from builtins.PyCapsule
- stub_atom2(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- stub_atom3(...) from builtins.PyCapsule
- stub_atom3(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- transform_Ax_plus_b_recursive(...) from builtins.PyCapsule
- transform_Ax_plus_b_recursive(self : rosetta.core.kinematics.tree.Atom, A : rosetta.numeric.xyzMatrix_double_t, b : rosetta.numeric.xyzVector_double_t, res_change_list : core::kinematics::ResidueCoordinateChangeList) -> NoneType
Transform atom and children by linear transformation
- update_stub(...) from builtins.PyCapsule
- update_stub(self : rosetta.core.kinematics.tree.Atom, stub : rosetta.core.kinematics.Stub) -> NoneType
update the stub without actually updating coordinates
|
class BondedAtom(Atom_) |
| |
an atom which are bonded to its parent, derived from Atom_
See
|
| |
- Method resolution order:
- BondedAtom
- Atom_
- Atom
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(handle, rosetta.core.kinematics.tree.BondedAtom) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.kinematics.tree.BondedAtom, : rosetta.core.kinematics.tree.BondedAtom) -> rosetta.core.kinematics.tree.BondedAtom
- clone(...) from builtins.PyCapsule
- clone(self : rosetta.core.kinematics.tree.BondedAtom, parent_in : rosetta.std.weak_ptr_core_kinematics_tree_Atom_t, atom_pointer : rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) -> rosetta.core.kinematics.tree.Atom
copy this atom
- copy_coords(...) from builtins.PyCapsule
- copy_coords(self : rosetta.core.kinematics.tree.BondedAtom, src : rosetta.core.kinematics.tree.Atom) -> NoneType
copy DOFs, xyz's
- dfs(...) from builtins.PyCapsule
- dfs(self : rosetta.core.kinematics.tree.BondedAtom, changeset : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange, res_change_list : rosetta.core.kinematics.ResidueCoordinateChangeList, start_atom_index : int) -> NoneType
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.
- dof(...) from builtins.PyCapsule
- dof(self : rosetta.core.kinematics.tree.BondedAtom, type : rosetta.core.id.DOF_Type) -> float
get degrees of freedom
- get_dof_axis_and_end_pos(...) from builtins.PyCapsule
- get_dof_axis_and_end_pos(self : rosetta.core.kinematics.tree.BondedAtom, axis : rosetta.numeric.xyzVector_double_t, end_pos : rosetta.numeric.xyzVector_double_t, type : rosetta.core.id.DOF_Type) -> NoneType
get rotation axis and end_pos for a BondedAtom.
- get_inversion(...) from builtins.PyCapsule
- get_inversion(rosetta.core.kinematics.tree.BondedAtom) -> bool
- is_jump(...) from builtins.PyCapsule
- is_jump(rosetta.core.kinematics.tree.BondedAtom) -> bool
bonded atom is a jump? of course not!!!
- jump(...) from builtins.PyCapsule
- jump(*args, **kwargs)
Overloaded function.
1. jump(rosetta.core.kinematics.tree.BondedAtom) -> rosetta.core.kinematics.Jump
abort if attempt to get jump for a bonded atom
2. jump(self : rosetta.core.kinematics.tree.BondedAtom, : rosetta.core.kinematics.Jump) -> NoneType
abort if attempt to set jump for a bonded atom
3. jump(self : rosetta.core.kinematics.tree.BondedAtom, : rosetta.core.kinematics.Jump, : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> NoneType
abort if attempt to set jump for a bonded atom
- keep_1st_child_pos(...) from builtins.PyCapsule
- keep_1st_child_pos(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
- keep_dof_fixed(...) from builtins.PyCapsule
- keep_dof_fixed(self : rosetta.core.kinematics.tree.BondedAtom, type : rosetta.core.id.DOF_Type) -> bool
whether a DOF for this atom should be fixed?
- raw_stub_atom1(...) from builtins.PyCapsule
- raw_stub_atom1(rosetta.core.kinematics.tree.BondedAtom) -> rosetta.core.kinematics.tree.Atom
- raw_stub_atom2(...) from builtins.PyCapsule
- raw_stub_atom2(rosetta.core.kinematics.tree.BondedAtom) -> rosetta.core.kinematics.tree.Atom
- raw_stub_atom3(...) from builtins.PyCapsule
- raw_stub_atom3(rosetta.core.kinematics.tree.BondedAtom) -> rosetta.core.kinematics.tree.Atom
- set_dof(...) from builtins.PyCapsule
- set_dof(*args, **kwargs)
Overloaded function.
1. set_dof(self : rosetta.core.kinematics.tree.BondedAtom, type : rosetta.core.id.DOF_Type, value : float) -> NoneType
set degrees of freedom (internal coordinates)
2. set_dof(self : rosetta.core.kinematics.tree.BondedAtom, type : rosetta.core.id.DOF_Type, value : float, changeset : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> NoneType
set degrees of freedom (internal coordinates). For use in
output-sensitive refold subroutine.
- setup_min_map(...) from builtins.PyCapsule
- setup_min_map(self : rosetta.core.kinematics.tree.BondedAtom, last_torsion : rosetta.core.id.DOF_ID, allow_move : rosetta.core.id.DOF_ID_Map_bool_t, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType
////////////////////////////////////////////////////////////////////////
for minimizing,add DOF(PHI,THETA,D) for a BondedAtom into the MinimizerMap
- steal_inversion(...) from builtins.PyCapsule
- steal_inversion(self : rosetta.core.kinematics.tree.BondedAtom, steal_from : rosetta.core.kinematics.tree.Atom) -> NoneType
- stub_atom1(...) from builtins.PyCapsule
- stub_atom1(rosetta.core.kinematics.tree.BondedAtom) -> rosetta.core.kinematics.tree.Atom
//////////////////////////////////////////////////////////////////////////
stub_atom1 of a bonded atom
it is itself
- stub_atom2(...) from builtins.PyCapsule
- stub_atom2(rosetta.core.kinematics.tree.BondedAtom) -> rosetta.core.kinematics.tree.Atom
//////////////////////////////////////////////////////////////////////////
stub_atom2 of a bonded atom
it is its parent
- stub_atom3(...) from builtins.PyCapsule
- stub_atom3(rosetta.core.kinematics.tree.BondedAtom) -> 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)
- update_internal_coords(...) from builtins.PyCapsule
- update_internal_coords(*args, **kwargs)
Overloaded function.
1. update_internal_coords(self : rosetta.core.kinematics.tree.BondedAtom, stub : rosetta.core.kinematics.Stub) -> NoneType
update internal coordinates for this atom from its xyz position and input stub
2. update_internal_coords(self : rosetta.core.kinematics.tree.BondedAtom, stub : rosetta.core.kinematics.Stub, recursive : bool) -> NoneType
update internal coordinates for this atom from its xyz position and input stub
- update_stub(...) from builtins.PyCapsule
- update_stub(self : rosetta.core.kinematics.tree.BondedAtom, stub : rosetta.core.kinematics.Stub) -> NoneType
update the stub without actually updating coordinates
- update_xyz_coords(...) from builtins.PyCapsule
- update_xyz_coords(*args, **kwargs)
Overloaded function.
1. update_xyz_coords(rosetta.core.kinematics.tree.BondedAtom) -> NoneType
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.
2. update_xyz_coords(self : rosetta.core.kinematics.tree.BondedAtom, stub : rosetta.core.kinematics.Stub) -> NoneType
update cartesian coordinates for this atom from its input stub and internal cooridnates
Methods inherited from Atom_:
- append_atom(...) from builtins.PyCapsule
- append_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom) -> NoneType
append an atom as this atom's child
- atom_id(...) from builtins.PyCapsule
- atom_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
Atom identifier
- atoms_begin(...) from builtins.PyCapsule
- atoms_begin(*args, **kwargs)
Overloaded function.
1. atoms_begin(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom> const*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
starting const iterator of the children atom list
2. atoms_begin(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom>*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
starting iterator of the children atom list
- atoms_end(...) from builtins.PyCapsule
- atoms_end(*args, **kwargs)
Overloaded function.
1. atoms_end(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom> const*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
ending const iterator of the children atom list
2. atoms_end(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom>*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
ending iterator of the children atom list
- child(...) from builtins.PyCapsule
- child(*args, **kwargs)
Overloaded function.
1. child(self : rosetta.core.kinematics.tree.Atom_, k : int) -> rosetta.core.kinematics.tree.Atom
get a child atom by index (const method)
2. child(self : rosetta.core.kinematics.tree.Atom_, k : int) -> rosetta.core.kinematics.tree.Atom
get a child atom by index
- child_index(...) from builtins.PyCapsule
- child_index(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> int
the atom-index of this child
- delete_atom(...) from builtins.PyCapsule
- delete_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom) -> NoneType
remove an atom from this atom's children
- dihedral_between_bonded_children(...) from builtins.PyCapsule
- dihedral_between_bonded_children(self : rosetta.core.kinematics.tree.Atom_, child1 : rosetta.core.kinematics.tree.Atom, child2 : rosetta.core.kinematics.tree.Atom) -> float
dihedral angle between two bonded children to this atom
- distance(...) from builtins.PyCapsule
- distance(self : rosetta.core.kinematics.tree.Atom_, atom : rosetta.core.kinematics.tree.Atom) -> float
Distance to an Atom
- distance_squared(...) from builtins.PyCapsule
- distance_squared(self : rosetta.core.kinematics.tree.Atom_, atom : rosetta.core.kinematics.tree.Atom) -> float
Distance squared to an Atom
- downstream(...) from builtins.PyCapsule
- downstream(self : rosetta.core.kinematics.tree.Atom_, atom1 : rosetta.core.kinematics.tree.Atom) -> bool
whether atom1 is downstream of this atom.
- get_input_stub(...) from builtins.PyCapsule
- get_input_stub(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.Stub
stub used to build this atom
- get_nonjump_atom(...) from builtins.PyCapsule
- get_nonjump_atom(self : rosetta.core.kinematics.tree.Atom_, i : int) -> rosetta.core.kinematics.tree.Atom
get non-jump atom by its index from the children atoms list
- get_stub(...) from builtins.PyCapsule
- get_stub(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.Stub
stub centerd at this atom
- id(...) from builtins.PyCapsule
- id(*args, **kwargs)
Overloaded function.
1. id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
Atom identifier
2. id(self : rosetta.core.kinematics.tree.Atom_, id_in : rosetta.core.id.AtomID) -> NoneType
AtomID assignment
- input_stub_atom0(...) from builtins.PyCapsule
- input_stub_atom0(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
the center of the input stub for refolding this atom
it is its parent
- input_stub_atom0_id(...) from builtins.PyCapsule
- input_stub_atom0_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom0's id
- input_stub_atom1(...) from builtins.PyCapsule
- input_stub_atom1(rosetta.core.kinematics.tree.Atom_) -> 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
- input_stub_atom1_id(...) from builtins.PyCapsule
- input_stub_atom1_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom1's id
- input_stub_atom2(...) from builtins.PyCapsule
- input_stub_atom2(rosetta.core.kinematics.tree.Atom_) -> 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
- input_stub_atom2_id(...) from builtins.PyCapsule
- input_stub_atom2_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom2's id
- input_stub_atom3(...) from builtins.PyCapsule
- input_stub_atom3(rosetta.core.kinematics.tree.Atom_) -> 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,
- input_stub_atom3_id(...) from builtins.PyCapsule
- input_stub_atom3_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom3's id
- insert_atom(...) from builtins.PyCapsule
- insert_atom(*args, **kwargs)
Overloaded function.
1. insert_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom) -> NoneType
insert an atom as this atom's child
2. insert_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom, : int) -> NoneType
tries to insert at the position specified by the second argument
- n_atom(...) from builtins.PyCapsule
- n_atom(rosetta.core.kinematics.tree.Atom_) -> int
number of children atoms
- n_children(...) from builtins.PyCapsule
- n_children(rosetta.core.kinematics.tree.Atom_) -> int
number of the child atoms
- n_nonjump_children(...) from builtins.PyCapsule
- n_nonjump_children(rosetta.core.kinematics.tree.Atom_) -> int
number of the non-jump child atoms
- next_child(...) from builtins.PyCapsule
- next_child(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
find the child atom after this child in the list
- parent(...) from builtins.PyCapsule
- parent(*args, **kwargs)
Overloaded function.
1. parent(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
Parent atom pointer
2. parent(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
Parent atom pointer
3. parent(self : rosetta.core.kinematics.tree.Atom_, parent_in : rosetta.std.weak_ptr_core_kinematics_tree_Atom_t) -> NoneType
- position(...) from builtins.PyCapsule
- position(*args, **kwargs)
Overloaded function.
1. position(rosetta.core.kinematics.tree.Atom_) -> rosetta.numeric.xyzVector_double_t
Position
2. position(self : rosetta.core.kinematics.tree.Atom_, position_a : rosetta.numeric.xyzVector_double_t) -> NoneType
Position assignment
- previous_child(...) from builtins.PyCapsule
- previous_child(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
find the child atom before this child in the list
- previous_sibling(...) from builtins.PyCapsule
- previous_sibling(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
routines for navigating the tree
find the sibling atom before itself
- raw_child_index(...) from builtins.PyCapsule
- raw_child_index(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> int
the atom-index of this child
- raw_get_nonjump_atom(...) from builtins.PyCapsule
- raw_get_nonjump_atom(self : rosetta.core.kinematics.tree.Atom_, i : int) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom0(...) from builtins.PyCapsule
- raw_input_stub_atom0(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom1(...) from builtins.PyCapsule
- raw_input_stub_atom1(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom2(...) from builtins.PyCapsule
- raw_input_stub_atom2(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom3(...) from builtins.PyCapsule
- raw_input_stub_atom3(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_parent(...) from builtins.PyCapsule
- raw_parent(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_previous_child(...) from builtins.PyCapsule
- raw_previous_child(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- raw_previous_sibling(...) from builtins.PyCapsule
- raw_previous_sibling(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- replace_atom(...) from builtins.PyCapsule
- replace_atom(self : rosetta.core.kinematics.tree.Atom_, old_atom : rosetta.core.kinematics.tree.Atom, new_atom : rosetta.core.kinematics.tree.Atom) -> NoneType
replace the old atom by the new atom in the child atom list
- show(...) from builtins.PyCapsule
- show(*args, **kwargs)
Overloaded function.
1. show(rosetta.core.kinematics.tree.Atom_) -> NoneType
dump out AtomID for this atom, its parent and all its offspring
2. show(self : rosetta.core.kinematics.tree.Atom_, n_level : int) -> NoneType
dump out AtomID for this atom, its parent and all its offspring up to n_level
- stub_atom1_id(...) from builtins.PyCapsule
- stub_atom1_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
stub atom1 's id
- stub_atom2_id(...) from builtins.PyCapsule
- stub_atom2_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
stub atom2's id
- stub_atom3_id(...) from builtins.PyCapsule
- stub_atom3_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
stub atom3's id
- stub_defined(...) from builtins.PyCapsule
- stub_defined(rosetta.core.kinematics.tree.Atom_) -> bool
whether a Stub can be defined for this atom
- update_domain_map(...) from builtins.PyCapsule
- update_domain_map(self : rosetta.core.kinematics.tree.Atom_, current_color : int, biggest_color : int, domain_map : ObjexxFCL::FArray1D<int>, dof_moved : rosetta.core.id.AtomID_Map_bool_t, atom_moved : rosetta.core.id.AtomID_Map_bool_t) -> NoneType
////////////////////////////////////////////////////////////////////////
update domain map
- x(...) from builtins.PyCapsule
- x(rosetta.core.kinematics.tree.Atom_) -> float
x coordinate
- xyz(...) from builtins.PyCapsule
- xyz(*args, **kwargs)
Overloaded function.
1. xyz(rosetta.core.kinematics.tree.Atom_) -> rosetta.numeric.xyzVector_double_t
Position
2. xyz(self : rosetta.core.kinematics.tree.Atom_, position_a : rosetta.numeric.xyzVector_double_t) -> NoneType
Position assignment
- y(...) from builtins.PyCapsule
- y(rosetta.core.kinematics.tree.Atom_) -> float
y coordinate
- z(...) from builtins.PyCapsule
- z(rosetta.core.kinematics.tree.Atom_) -> float
z coordinate
Methods inherited from Atom:
- atom_is_on_path_from_root(...) from builtins.PyCapsule
- atom_is_on_path_from_root(self : rosetta.core.kinematics.tree.Atom, atm : rosetta.core.kinematics.tree.Atom) -> bool
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
2. get_self_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- get_self_weak_ptr(...) from builtins.PyCapsule
- get_self_weak_ptr(*args, **kwargs)
Overloaded function.
1. get_self_weak_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.std.weak_ptr_const_core_kinematics_tree_Atom_t
2. get_self_weak_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.std.weak_ptr_core_kinematics_tree_Atom_t
- transform_Ax_plus_b_recursive(...) from builtins.PyCapsule
- transform_Ax_plus_b_recursive(self : rosetta.core.kinematics.tree.Atom, A : rosetta.numeric.xyzMatrix_double_t, b : rosetta.numeric.xyzVector_double_t, res_change_list : core::kinematics::ResidueCoordinateChangeList) -> NoneType
Transform atom and children by linear transformation
|
class JumpAtom(Atom_) |
| |
an atom who are connected to its parent via rigid-body transformation "Jump"
See
|
| |
- Method resolution order:
- JumpAtom
- Atom_
- Atom
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(handle, rosetta.core.kinematics.tree.JumpAtom) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.kinematics.tree.JumpAtom, : rosetta.core.kinematics.tree.JumpAtom) -> rosetta.core.kinematics.tree.JumpAtom
- clone(...) from builtins.PyCapsule
- clone(self : rosetta.core.kinematics.tree.JumpAtom, parent_in : rosetta.std.weak_ptr_core_kinematics_tree_Atom_t, atom_pointer : rosetta.core.id.AtomID_Map_std_shared_ptr_core_kinematics_tree_Atom_t) -> rosetta.core.kinematics.tree.Atom
copy this atom
- copy_coords(...) from builtins.PyCapsule
- copy_coords(self : rosetta.core.kinematics.tree.JumpAtom, src : rosetta.core.kinematics.tree.Atom) -> NoneType
copy DOFs, xyz's
- dfs(...) from builtins.PyCapsule
- dfs(self : rosetta.core.kinematics.tree.JumpAtom, changeset : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange, res_change_list : rosetta.core.kinematics.ResidueCoordinateChangeList, start_atom_index : int) -> NoneType
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.
- dof(...) from builtins.PyCapsule
- dof(self : rosetta.core.kinematics.tree.JumpAtom, type : rosetta.core.id.DOF_Type) -> float
get a degree of freedom from jump
- get_dof_axis_and_end_pos(...) from builtins.PyCapsule
- get_dof_axis_and_end_pos(self : rosetta.core.kinematics.tree.JumpAtom, axis : rosetta.numeric.xyzVector_double_t, end_pos : rosetta.numeric.xyzVector_double_t, type : rosetta.core.id.DOF_Type) -> NoneType
get rotation axis and end_pos for a JumpAtom.
- get_inversion(...) from builtins.PyCapsule
- get_inversion(rosetta.core.kinematics.tree.JumpAtom) -> (bool, bool)
- is_jump(...) from builtins.PyCapsule
- is_jump(rosetta.core.kinematics.tree.JumpAtom) -> bool
a jump atom is a jump? of course yes!!!
- jump(...) from builtins.PyCapsule
- jump(*args, **kwargs)
Overloaded function.
1. jump(rosetta.core.kinematics.tree.JumpAtom) -> rosetta.core.kinematics.Jump
access the jump
2. jump(self : rosetta.core.kinematics.tree.JumpAtom, jump_in : rosetta.core.kinematics.Jump) -> NoneType
set the jump
3. jump(self : rosetta.core.kinematics.tree.JumpAtom, jump_in : rosetta.core.kinematics.Jump, changeset : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> NoneType
set the jump. For use with output-sensitive refold subroutine.
- keep_1st_child_pos(...) from builtins.PyCapsule
- keep_1st_child_pos(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
- keep_dof_fixed(...) from builtins.PyCapsule
- keep_dof_fixed(self : rosetta.core.kinematics.tree.JumpAtom, type : rosetta.core.id.DOF_Type) -> bool
whether a jump should be fixed in some special cases
- raw_stub_atom1(...) from builtins.PyCapsule
- raw_stub_atom1(rosetta.core.kinematics.tree.JumpAtom) -> rosetta.core.kinematics.tree.Atom
- raw_stub_atom2(...) from builtins.PyCapsule
- raw_stub_atom2(rosetta.core.kinematics.tree.JumpAtom) -> rosetta.core.kinematics.tree.Atom
- raw_stub_atom3(...) from builtins.PyCapsule
- raw_stub_atom3(rosetta.core.kinematics.tree.JumpAtom) -> rosetta.core.kinematics.tree.Atom
- set_dof(...) from builtins.PyCapsule
- set_dof(*args, **kwargs)
Overloaded function.
1. set_dof(self : rosetta.core.kinematics.tree.JumpAtom, type : rosetta.core.id.DOF_Type, value : float) -> NoneType
set a degree of freedom for jump
2. set_dof(self : rosetta.core.kinematics.tree.JumpAtom, type : rosetta.core.id.DOF_Type, value : float, changeset : rosetta.utility.vector1_core_kinematics_AtomWithDOFChange) -> NoneType
set degrees of freedom (internal coordinates). For use in
output-sensitive refold subroutine.
- setup_min_map(...) from builtins.PyCapsule
- setup_min_map(self : rosetta.core.kinematics.tree.JumpAtom, last_torsion : rosetta.core.id.DOF_ID, allow_move : rosetta.core.id.DOF_ID_Map_bool_t, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType
////////////////////////////////////////////////////////////////////////
for minimizing, add DOF(RB) for a JumpAtom into the MinimizerMap
- steal_inversion(...) from builtins.PyCapsule
- steal_inversion(self : rosetta.core.kinematics.tree.JumpAtom, steal_from : rosetta.core.kinematics.tree.Atom) -> NoneType
- stub_atom1(...) from builtins.PyCapsule
- stub_atom1(rosetta.core.kinematics.tree.JumpAtom) -> 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
- stub_atom2(...) from builtins.PyCapsule
- stub_atom2(rosetta.core.kinematics.tree.JumpAtom) -> 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.
- stub_atom3(...) from builtins.PyCapsule
- stub_atom3(rosetta.core.kinematics.tree.JumpAtom) -> 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
- update_internal_coords(...) from builtins.PyCapsule
- update_internal_coords(*args, **kwargs)
Overloaded function.
1. update_internal_coords(self : rosetta.core.kinematics.tree.JumpAtom, stub : rosetta.core.kinematics.Stub) -> NoneType
update the jump info
2. update_internal_coords(self : rosetta.core.kinematics.tree.JumpAtom, stub : rosetta.core.kinematics.Stub, recursive : bool) -> NoneType
update the jump info
- update_stub(...) from builtins.PyCapsule
- update_stub(self : rosetta.core.kinematics.tree.JumpAtom, : rosetta.core.kinematics.Stub) -> NoneType
update the stub without actually updating coordinates
since for a jump atom, update internal coords or xyz dont change input
jump, so we do not do anything here
- update_xyz_coords(...) from builtins.PyCapsule
- update_xyz_coords(*args, **kwargs)
Overloaded function.
1. update_xyz_coords(rosetta.core.kinematics.tree.JumpAtom) -> NoneType
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.
2. update_xyz_coords(self : rosetta.core.kinematics.tree.JumpAtom, stub : rosetta.core.kinematics.Stub) -> NoneType
update this atom's xyz position
Methods inherited from Atom_:
- append_atom(...) from builtins.PyCapsule
- append_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom) -> NoneType
append an atom as this atom's child
- atom_id(...) from builtins.PyCapsule
- atom_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
Atom identifier
- atoms_begin(...) from builtins.PyCapsule
- atoms_begin(*args, **kwargs)
Overloaded function.
1. atoms_begin(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom> const*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
starting const iterator of the children atom list
2. atoms_begin(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom>*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
starting iterator of the children atom list
- atoms_end(...) from builtins.PyCapsule
- atoms_end(*args, **kwargs)
Overloaded function.
1. atoms_end(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom> const*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
ending const iterator of the children atom list
2. atoms_end(rosetta.core.kinematics.tree.Atom_) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::kinematics::tree::Atom>*, std::vector<std::shared_ptr<core::kinematics::tree::Atom>, std::allocator<std::shared_ptr<core::kinematics::tree::Atom> > > >
ending iterator of the children atom list
- child(...) from builtins.PyCapsule
- child(*args, **kwargs)
Overloaded function.
1. child(self : rosetta.core.kinematics.tree.Atom_, k : int) -> rosetta.core.kinematics.tree.Atom
get a child atom by index (const method)
2. child(self : rosetta.core.kinematics.tree.Atom_, k : int) -> rosetta.core.kinematics.tree.Atom
get a child atom by index
- child_index(...) from builtins.PyCapsule
- child_index(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> int
the atom-index of this child
- delete_atom(...) from builtins.PyCapsule
- delete_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom) -> NoneType
remove an atom from this atom's children
- dihedral_between_bonded_children(...) from builtins.PyCapsule
- dihedral_between_bonded_children(self : rosetta.core.kinematics.tree.Atom_, child1 : rosetta.core.kinematics.tree.Atom, child2 : rosetta.core.kinematics.tree.Atom) -> float
dihedral angle between two bonded children to this atom
- distance(...) from builtins.PyCapsule
- distance(self : rosetta.core.kinematics.tree.Atom_, atom : rosetta.core.kinematics.tree.Atom) -> float
Distance to an Atom
- distance_squared(...) from builtins.PyCapsule
- distance_squared(self : rosetta.core.kinematics.tree.Atom_, atom : rosetta.core.kinematics.tree.Atom) -> float
Distance squared to an Atom
- downstream(...) from builtins.PyCapsule
- downstream(self : rosetta.core.kinematics.tree.Atom_, atom1 : rosetta.core.kinematics.tree.Atom) -> bool
whether atom1 is downstream of this atom.
- get_input_stub(...) from builtins.PyCapsule
- get_input_stub(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.Stub
stub used to build this atom
- get_nonjump_atom(...) from builtins.PyCapsule
- get_nonjump_atom(self : rosetta.core.kinematics.tree.Atom_, i : int) -> rosetta.core.kinematics.tree.Atom
get non-jump atom by its index from the children atoms list
- get_stub(...) from builtins.PyCapsule
- get_stub(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.Stub
stub centerd at this atom
- id(...) from builtins.PyCapsule
- id(*args, **kwargs)
Overloaded function.
1. id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
Atom identifier
2. id(self : rosetta.core.kinematics.tree.Atom_, id_in : rosetta.core.id.AtomID) -> NoneType
AtomID assignment
- input_stub_atom0(...) from builtins.PyCapsule
- input_stub_atom0(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
the center of the input stub for refolding this atom
it is its parent
- input_stub_atom0_id(...) from builtins.PyCapsule
- input_stub_atom0_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom0's id
- input_stub_atom1(...) from builtins.PyCapsule
- input_stub_atom1(rosetta.core.kinematics.tree.Atom_) -> 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
- input_stub_atom1_id(...) from builtins.PyCapsule
- input_stub_atom1_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom1's id
- input_stub_atom2(...) from builtins.PyCapsule
- input_stub_atom2(rosetta.core.kinematics.tree.Atom_) -> 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
- input_stub_atom2_id(...) from builtins.PyCapsule
- input_stub_atom2_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom2's id
- input_stub_atom3(...) from builtins.PyCapsule
- input_stub_atom3(rosetta.core.kinematics.tree.Atom_) -> 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,
- input_stub_atom3_id(...) from builtins.PyCapsule
- input_stub_atom3_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
input stub atom3's id
- insert_atom(...) from builtins.PyCapsule
- insert_atom(*args, **kwargs)
Overloaded function.
1. insert_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom) -> NoneType
insert an atom as this atom's child
2. insert_atom(self : rosetta.core.kinematics.tree.Atom_, : rosetta.core.kinematics.tree.Atom, : int) -> NoneType
tries to insert at the position specified by the second argument
- n_atom(...) from builtins.PyCapsule
- n_atom(rosetta.core.kinematics.tree.Atom_) -> int
number of children atoms
- n_children(...) from builtins.PyCapsule
- n_children(rosetta.core.kinematics.tree.Atom_) -> int
number of the child atoms
- n_nonjump_children(...) from builtins.PyCapsule
- n_nonjump_children(rosetta.core.kinematics.tree.Atom_) -> int
number of the non-jump child atoms
- next_child(...) from builtins.PyCapsule
- next_child(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
find the child atom after this child in the list
- parent(...) from builtins.PyCapsule
- parent(*args, **kwargs)
Overloaded function.
1. parent(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
Parent atom pointer
2. parent(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
Parent atom pointer
3. parent(self : rosetta.core.kinematics.tree.Atom_, parent_in : rosetta.std.weak_ptr_core_kinematics_tree_Atom_t) -> NoneType
- position(...) from builtins.PyCapsule
- position(*args, **kwargs)
Overloaded function.
1. position(rosetta.core.kinematics.tree.Atom_) -> rosetta.numeric.xyzVector_double_t
Position
2. position(self : rosetta.core.kinematics.tree.Atom_, position_a : rosetta.numeric.xyzVector_double_t) -> NoneType
Position assignment
- previous_child(...) from builtins.PyCapsule
- previous_child(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
find the child atom before this child in the list
- previous_sibling(...) from builtins.PyCapsule
- previous_sibling(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
routines for navigating the tree
find the sibling atom before itself
- raw_child_index(...) from builtins.PyCapsule
- raw_child_index(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> int
the atom-index of this child
- raw_get_nonjump_atom(...) from builtins.PyCapsule
- raw_get_nonjump_atom(self : rosetta.core.kinematics.tree.Atom_, i : int) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom0(...) from builtins.PyCapsule
- raw_input_stub_atom0(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom1(...) from builtins.PyCapsule
- raw_input_stub_atom1(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom2(...) from builtins.PyCapsule
- raw_input_stub_atom2(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_input_stub_atom3(...) from builtins.PyCapsule
- raw_input_stub_atom3(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_parent(...) from builtins.PyCapsule
- raw_parent(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- raw_previous_child(...) from builtins.PyCapsule
- raw_previous_child(self : rosetta.core.kinematics.tree.Atom_, child : rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- raw_previous_sibling(...) from builtins.PyCapsule
- raw_previous_sibling(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.kinematics.tree.Atom
- replace_atom(...) from builtins.PyCapsule
- replace_atom(self : rosetta.core.kinematics.tree.Atom_, old_atom : rosetta.core.kinematics.tree.Atom, new_atom : rosetta.core.kinematics.tree.Atom) -> NoneType
replace the old atom by the new atom in the child atom list
- show(...) from builtins.PyCapsule
- show(*args, **kwargs)
Overloaded function.
1. show(rosetta.core.kinematics.tree.Atom_) -> NoneType
dump out AtomID for this atom, its parent and all its offspring
2. show(self : rosetta.core.kinematics.tree.Atom_, n_level : int) -> NoneType
dump out AtomID for this atom, its parent and all its offspring up to n_level
- stub_atom1_id(...) from builtins.PyCapsule
- stub_atom1_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
stub atom1 's id
- stub_atom2_id(...) from builtins.PyCapsule
- stub_atom2_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
stub atom2's id
- stub_atom3_id(...) from builtins.PyCapsule
- stub_atom3_id(rosetta.core.kinematics.tree.Atom_) -> rosetta.core.id.AtomID
stub atom3's id
- stub_defined(...) from builtins.PyCapsule
- stub_defined(rosetta.core.kinematics.tree.Atom_) -> bool
whether a Stub can be defined for this atom
- update_domain_map(...) from builtins.PyCapsule
- update_domain_map(self : rosetta.core.kinematics.tree.Atom_, current_color : int, biggest_color : int, domain_map : ObjexxFCL::FArray1D<int>, dof_moved : rosetta.core.id.AtomID_Map_bool_t, atom_moved : rosetta.core.id.AtomID_Map_bool_t) -> NoneType
////////////////////////////////////////////////////////////////////////
update domain map
- x(...) from builtins.PyCapsule
- x(rosetta.core.kinematics.tree.Atom_) -> float
x coordinate
- xyz(...) from builtins.PyCapsule
- xyz(*args, **kwargs)
Overloaded function.
1. xyz(rosetta.core.kinematics.tree.Atom_) -> rosetta.numeric.xyzVector_double_t
Position
2. xyz(self : rosetta.core.kinematics.tree.Atom_, position_a : rosetta.numeric.xyzVector_double_t) -> NoneType
Position assignment
- y(...) from builtins.PyCapsule
- y(rosetta.core.kinematics.tree.Atom_) -> float
y coordinate
- z(...) from builtins.PyCapsule
- z(rosetta.core.kinematics.tree.Atom_) -> float
z coordinate
Methods inherited from Atom:
- atom_is_on_path_from_root(...) from builtins.PyCapsule
- atom_is_on_path_from_root(self : rosetta.core.kinematics.tree.Atom, atm : rosetta.core.kinematics.tree.Atom) -> bool
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
2. get_self_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.core.kinematics.tree.Atom
- get_self_weak_ptr(...) from builtins.PyCapsule
- get_self_weak_ptr(*args, **kwargs)
Overloaded function.
1. get_self_weak_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.std.weak_ptr_const_core_kinematics_tree_Atom_t
2. get_self_weak_ptr(rosetta.core.kinematics.tree.Atom) -> rosetta.std.weak_ptr_core_kinematics_tree_Atom_t
- transform_Ax_plus_b_recursive(...) from builtins.PyCapsule
- transform_Ax_plus_b_recursive(self : rosetta.core.kinematics.tree.Atom, A : rosetta.numeric.xyzMatrix_double_t, b : rosetta.numeric.xyzVector_double_t, res_change_list : core::kinematics::ResidueCoordinateChangeList) -> NoneType
Transform atom and children by linear transformation
| |