Home       Trees       Indices       Help   
Module rosetta :: Module core :: Module pose :: Class Pose
[hide private]
[frames] | no frames]

Class Pose

object --+
         |
        Pose

The Pose class represents a molecular system (protein-dna-ligand...)
as a container of Rosetta Residue objects together with
a Conformation object that defines how internal coordinate changes
propagate through the system and an Energies object that stores
information from the last energy evaluation.

The main responsibilities of the pose are:

  Kinematic:
(a) to update the xyz coordinates in response to changes to internal
degrees of freedom, and
(b) to update internal coordinates when the user modifes the xyz
(Cartesian) coords,

  Scoring:
(a) to keep track of what parts of the structure have changed since
the last score evaluation, and
(b) to cache residue and residue-pair energies for efficient re-use

 As a container:
The pose provides a single object for passing
a molecular system and for copying of entire molecules
or stretches of molecules from one Pose object into another.

Output Methods:
Common Methods:
Pose.assign
Pose.atom_tree
Pose.conformation
Pose.dump_pdb
Pose.dump_cif
Pose.dump_file
Pose.energies
Pose.fold_tree
Pose.pdb_info
Pose.residue
Pose.sequence
Pose.total_residue
Instance Methods [hide private]
 
__init__(*args, **kwargs)
Overloaded function.
a new object with type S, a subtype of T
__new__(T, S, ...)
unicode
__str__(rosetta.core.pose.Pose)
str(x)
 
aa(...)
aa(self : rosetta.core.pose.Pose, seqpos : int) -> rosetta.core.chemical.AA
 
add_constraint(...)
add_constraint(self : rosetta.core.pose.Pose, cst : core::scoring::constraints::Constraint) -> core::scoring::constraints::Constraint
 
add_constraints(...)
add_constraints(self : rosetta.core.pose.Pose, csts : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
 
alpha(...)
alpha(self : rosetta.core.pose.Pose, pos : int) -> float
 
annotated_sequence(*args, **kwargs)
Overloaded function.
 
append_polymer_residue_after_seqpos(...)
append_polymer_residue_after_seqpos(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, seqpos : int, build_ideal_geometry : bool) -> NoneType
 
append_pose_by_jump(*args, **kwargs)
Overloaded function.
 
append_residue_by_atoms(*args, **kwargs)
Overloaded function.
 
append_residue_by_bond(*args, **kwargs)
Overloaded function.
 
append_residue_by_jump(*args, **kwargs)
Overloaded function.
 
apply_transform_Rx_plus_v(...)
apply_transform_Rx_plus_v(self : rosetta.core.pose.Pose, R : rosetta.numeric.xyzMatrix_double_t, v : rosetta.numeric.xyzVector_double_t) -> NoneType
 
assign(...)
assign(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose) -> rosetta.core.pose.Pose
core::kinematics::AtomTree
atom_tree(rosetta.core.pose.Pose)
Returns the pose AtomTree
 
batch_get_xyz(...)
batch_get_xyz(self : rosetta.core.pose.Pose, ids : rosetta.utility.vector1_core_id_AtomID, points : rosetta.utility.vector1_numeric_xyzVector_double_t) -> NoneType
 
batch_set_xyz(...)
batch_set_xyz(self : rosetta.core.pose.Pose, ids : rosetta.utility.vector1_core_id_AtomID, points : rosetta.utility.vector1_numeric_xyzVector_double_t) -> NoneType
 
beta(...)
beta(self : rosetta.core.pose.Pose, seqpos : int) -> float
NoneType
center(rosetta.core.pose.Pose)
Sets pose coordinates such that the pose center is at the Euclidean origin
 
chain(...)
chain(self : rosetta.core.pose.Pose, seqpos : int) -> int
 
chain_sequence(...)
chain_sequence(self : rosetta.core.pose.Pose, chain_in : int) -> unicode
 
chi(*args, **kwargs)
Overloaded function.
NoneType
clear(rosetta.core.pose.Pose)
Empty the pose contents
NoneType
clear_sequence_constraints(rosetta.core.pose.Pose)
Remove all sequence constraints from this pose.
rosetta.core.pose.Pose
clone(rosetta.core.pose.Pose)
clone the conformation
 
conformation(*args, **kwargs)
Overloaded function.
 
conformation_ptr(*args, **kwargs)
Overloaded function.
rosetta.basic.datacache.ConstDataMap
const_data_cache(rosetta.core.pose.Pose)
Read access to the const data cache
 
constraint_set(*args, **kwargs)
Overloaded function.
 
copy_segment(...)
copy_segment(self : rosetta.core.pose.Pose, size : int, src : rosetta.core.pose.Pose, begin : int, src_begin : int) -> NoneType
 
corresponding_residue_in_current(...)
corresponding_residue_in_current(self : rosetta.core.pose.Pose, ref_residue_index : int, ref_pose_name : unicode) -> int
 
data(*args, **kwargs)
Overloaded function.
 
decrement_reference_pose_mapping_after_seqpos(...)
decrement_reference_pose_mapping_after_seqpos(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType
 
delete_polymer_residue(...)
delete_polymer_residue(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType
 
delete_residue_range_slow(...)
delete_residue_range_slow(self : rosetta.core.pose.Pose, start : int, end : int) -> NoneType
 
delete_residue_slow(...)
delete_residue_slow(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType
 
delta(...)
delta(self : rosetta.core.pose.Pose, pos : int) -> float
 
detached_copy(...)
detached_copy(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose) -> NoneType
 
dof(...)
dof(self : rosetta.core.pose.Pose, id : rosetta.core.id.DOF_ID) -> float
 
dump_cif(...)
dump_cif(self : rosetta.core.pose.Pose, file_name : unicode) -> NoneType
 
dump_file(...)
dump_file(self : rosetta.core.pose.Pose, file_name : unicode) -> NoneType
 
dump_pdb(*args, **kwargs)
Overloaded function.
 
dump_scored_pdb(*args, **kwargs)
Overloaded function.
bool
empty(rosetta.core.pose.Pose)
Returns true if there are no residues in the conformation
 
energies(*args, **kwargs)
Overloaded function.
 
epsilon(...)
epsilon(self : rosetta.core.pose.Pose, seqpos : int) -> float
 
fold_tree(*args, **kwargs)
Overloaded function.
 
gamma(...)
gamma(self : rosetta.core.pose.Pose, seqpos : int) -> float
 
get_self_ptr(*args, **kwargs)
Overloaded function.
 
get_self_weak_ptr(*args, **kwargs)
Overloaded function.
 
has_dof(...)
has_dof(self : rosetta.core.pose.Pose, id : rosetta.core.id.DOF_ID) -> bool
bool
has_reference_pose(rosetta.core.pose.Pose)
Returns true if a pose has at least one reference pose, false otherwise.
 
increment_reference_pose_mapping_after_seqpos(...)
increment_reference_pose_mapping_after_seqpos(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType
 
insert_residue_by_bond(*args, **kwargs)
Overloaded function.
 
insert_residue_by_jump(*args, **kwargs)
Overloaded function.
bool
is_centroid(rosetta.core.pose.Pose)
Returns true if pose is ResidueType centroid
bool
is_fullatom(rosetta.core.pose.Pose)
Returns true if pose is ResidueType fullatom
 
jump(*args, **kwargs)
Overloaded function.
 
metric(...)
metric(self : rosetta.core.pose.Pose, calculator_name : unicode, key : unicode, val : rosetta.basic.MetricValueBase) -> NoneType
int
n_residue(rosetta.core.pose.Pose)
Returns the number of residues in the pose conformation...
int
num_jump(rosetta.core.pose.Pose)
Returns the number of jumps in the pose FoldTree
 
observer_cache(*args, **kwargs)
Overloaded function.
 
omega(...)
omega(self : rosetta.core.pose.Pose, seqpos : int) -> float
 
pdb_info(*args, **kwargs)
Overloaded function.
 
phi(...)
phi(self : rosetta.core.pose.Pose, seqpos : int) -> float
 
prepend_polymer_residue_before_seqpos(...)
prepend_polymer_residue_before_seqpos(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, seqpos : int, build_ideal_geometry : bool) -> NoneType
 
print_metric(...)
print_metric(self : rosetta.core.pose.Pose, calculator_name : unicode, key : unicode) -> unicode
 
psi(...)
psi(self : rosetta.core.pose.Pose, seqpos : int) -> float
 
reference_pose_from_current(*args, **kwargs)
Overloaded function.
core::pose::reference_pose::ReferencePoseSet
reference_pose_set(rosetta.core.pose.Pose)
Access the ReferencePoseSet object (non-const).
core::pose::reference_pose::ReferencePoseSet
reference_pose_set_cop(rosetta.core.pose.Pose)
Const-access the ReferencePoseSet object.
 
remove_constraint(*args, **kwargs)
Overloaded function.
 
remove_constraints(*args, **kwargs)
Overloaded function.
 
replace_residue(*args, **kwargs)
Overloaded function.
 
residue(...)
residue(self : rosetta.core.pose.Pose, seqpos : int) -> rosetta.core.conformation.Residue
 
residue_type(...)
residue_type(self : rosetta.core.pose.Pose, seqpos : int) -> rosetta.core.chemical.ResidueType
 
scoring_begin(...)
scoring_begin(self : rosetta.core.pose.Pose, info : core::scoring::ScoreFunction) -> NoneType
 
scoring_end(...)
scoring_end(self : rosetta.core.pose.Pose, scorefxn : core::scoring::ScoreFunction) -> NoneType
 
secstruct(*args, **kwargs)
Overloaded function.
 
sequence(*args, **kwargs)
Overloaded function.
 
set_alpha(...)
set_alpha(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
set_beta(...)
set_beta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
set_chi(*args, **kwargs)
Overloaded function.
 
set_delta(...)
set_delta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
set_dof(...)
set_dof(self : rosetta.core.pose.Pose, id : rosetta.core.id.DOF_ID, setting : float) -> NoneType
 
set_epsilon(...)
set_epsilon(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
set_gamma(...)
set_gamma(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
set_jump(*args, **kwargs)
Overloaded function.
 
set_new_conformation(...)
set_new_conformation(self : rosetta.core.pose.Pose, new_conformation : rosetta.core.conformation.Conformation) -> NoneType
 
set_new_energies_object(...)
set_new_energies_object(self : rosetta.core.pose.Pose, energies : core::scoring::Energies) -> NoneType
 
set_omega(...)
set_omega(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
set_phi(...)
set_phi(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
set_psi(...)
set_psi(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
set_ring_conformation(...)
set_ring_conformation(self : rosetta.core.pose.Pose, seqpos : int, ring_num : int, conformer : rosetta.core.chemical.rings.RingConformer) -> NoneType
 
set_secstruct(...)
set_secstruct(self : rosetta.core.pose.Pose, seqpos : int, setting : unicode) -> NoneType
 
set_theta(...)
set_theta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
set_torsion(...)
set_torsion(self : rosetta.core.pose.Pose, id : core::id::TorsionID, setting : float) -> NoneType
 
set_xyz(*args, **kwargs)
Overloaded function.
 
set_zeta(...)
set_zeta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType
 
split_by_chain(*args, **kwargs)
Overloaded function.
 
stub_from_id(...)
stub_from_id(self : rosetta.core.pose.Pose, id : core::id::NamedStubID) -> rosetta.core.kinematics.Stub
 
theta(...)
theta(self : rosetta.core.pose.Pose, seqpos : int) -> float
 
torsion(...)
torsion(self : rosetta.core.pose.Pose, id : core::id::TorsionID) -> float
 
total_atoms(*args, **kwargs)
Overloaded function.
int
total_residue(rosetta.core.pose.Pose)
Returns the number of residues in the pose conformation
 
transfer_constraint_set(...)
transfer_constraint_set(self : rosetta.core.pose.Pose, pose : rosetta.core.pose.Pose) -> NoneType
 
update_actcoord(...)
update_actcoord(self : rosetta.core.pose.Pose, resid : int) -> NoneType
NoneType
update_actcoords(rosetta.core.pose.Pose)
Called by PairEPotential to update the action coordinates for all residues
 
update_orbital_coords(...)
update_orbital_coords(self : rosetta.core.pose.Pose, resid : int) -> NoneType
NoneType
update_pose_chains_from_pdb_chains(rosetta.core.pose.Pose)
Updates the pose chain IDs to match the pdb chain IDs.
NoneType
update_residue_neighbors(rosetta.core.pose.Pose)
Updates neighbor links in the pose Energies object
 
xyz(*args, **kwargs)
Overloaded function.
 
zero_reference_pose_mapping_at_seqpos(...)
zero_reference_pose_mapping_at_seqpos(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType
 
zeta(...)
zeta(self : rosetta.core.pose.Pose, seqpos : int) -> float

Inherited from object: __delattr__, __format__, __getattribute__, __hash__, __reduce__, __reduce_ex__, __repr__, __setattr__, __sizeof__, __subclasshook__

Properties [hide private]

Inherited from object: __class__

Method Details [hide private]

__init__(*args, **kwargs)
(Constructor)

  
Overloaded function.

1. __init__(rosetta.core.pose.Pose) -> NoneType

2. __init__(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose) -> NoneType

3. __init__(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose, residue_begin : int, residue_end : int) -> NoneType
Overrides: object.__init__

__new__(T, S, ...)

 
Returns: a new object with type S, a subtype of T
Overrides: object.__new__

__str__(rosetta.core.pose.Pose)
(Informal representation operator)

 

str(x)

Returns: unicode
Overrides: object.__str__

aa(...)

  
aa(self : rosetta.core.pose.Pose, seqpos : int) -> rosetta.core.chemical.AA

Returns the chemical::AA of the residue at  <seqpos>

 example(s):
     pose.aa(17)
 See also:
     Pose
 Pose.Residue
     Pose.sequence
     Residue

add_constraint(...)

 

add_constraint(self : rosetta.core.pose.Pose, cst : core::scoring::constraints::Constraint) -> core::scoring::constraints::Constraint

adding a constraint is done by cloning the input constraint. A const copy is then returned

alpha(...)

  
alpha(self : rosetta.core.pose.Pose, pos : int) -> float

Returns the alpha torsion angle of residue  <seqpos>
 

 assumes the residue is an nucleic acid

 example(s):
     pose.alpha(1)
 See also:
     Pose
     Pose.residue
     Pose.set_alpha
     Residue

annotated_sequence(*args, **kwargs)

  
Overloaded function.

1. annotated_sequence(rosetta.core.pose.Pose) -> unicode

Returns the variant-tagged string representing the
 residue types that make up a conformation; e.g.
 M[MET:N-Terminus-Variant]CDH[HIS_D]LLR[ARG:C-Terminus-Variant]

 example(s):
     pose.annotated_sequence()
 See also:
     Pose
     Pose.sequence
     Pose.total_residue
 Residue

2. annotated_sequence(self : rosetta.core.pose.Pose, show_all_variants : bool) -> unicode

Returns the variant-tagged string representing the
 residue types that make up a conformation; e.g.
 M[MET:N-Terminus-Variant]CDH[HIS_D]LLR[ARG:C-Terminus-Variant]

 example(s):
     pose.annotated_sequence()
 See also:
     Pose
     Pose.sequence
     Pose.total_residue
 Residue

append_polymer_residue_after_seqpos(...)

 

append_polymer_residue_after_seqpos(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, seqpos : int, build_ideal_geometry : bool) -> NoneType

glues to seqpos and perhaps also seqpos+1

append_pose_by_jump(*args, **kwargs)

  
Overloaded function.

1. append_pose_by_jump(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose, jump_anchor_residue : int) -> NoneType

Appends source pose conformation to pose by a new jump

2. append_pose_by_jump(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose, jump_anchor_residue : int, jump_anchor_atom : unicode) -> NoneType

Appends source pose conformation to pose by a new jump

3. append_pose_by_jump(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose, jump_anchor_residue : int, jump_anchor_atom : unicode, jump_root_atom : unicode) -> NoneType

Appends source pose conformation to pose by a new jump

append_residue_by_atoms(*args, **kwargs)

  
Overloaded function.

1. append_residue_by_atoms(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connect_atom : unicode, anchor_rsd_seqpos : int, anchor_connect_atom : unicode) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond to a given atom

 
 This function effectively wraps append_residue_by_bond for an easier syntax. Instead
 of having to know what the connection, anchor residue, and anchor connection are, we give the
 atoms and query the ResidueType for the remaining information.

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

2. append_residue_by_atoms(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connect_atom : unicode, anchor_rsd_seqpos : int, anchor_connect_atom : unicode, start_new_chain : bool) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond to a given atom

 
 This function effectively wraps append_residue_by_bond for an easier syntax. Instead
 of having to know what the connection, anchor residue, and anchor connection are, we give the
 atoms and query the ResidueType for the remaining information.

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

3. append_residue_by_atoms(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connect_atom : unicode, anchor_rsd_seqpos : int, anchor_connect_atom : unicode, start_new_chain : bool, lookup_bond_length : bool) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond to a given atom

 
 This function effectively wraps append_residue_by_bond for an easier syntax. Instead
 of having to know what the connection, anchor residue, and anchor connection are, we give the
 atoms and query the ResidueType for the remaining information.

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

append_residue_by_bond(*args, **kwargs)

  
Overloaded function.

1. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond

 
 The default behavior is to append by a polymeric connection to the preceding residue
 If we want to connect via a non-polymer connection, we give the connection number, anchor residue
 and the connection number for the anchor residue. These connection numbers are wrt the connections_
 arrays in Residue and ResidueType

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

2. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond

 
 The default behavior is to append by a polymeric connection to the preceding residue
 If we want to connect via a non-polymer connection, we give the connection number, anchor residue
 and the connection number for the anchor residue. These connection numbers are wrt the connections_
 arrays in Residue and ResidueType

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

3. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond

 
 The default behavior is to append by a polymeric connection to the preceding residue
 If we want to connect via a non-polymer connection, we give the connection number, anchor residue
 and the connection number for the anchor residue. These connection numbers are wrt the connections_
 arrays in Residue and ResidueType

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

4. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int, anchor_residue : int) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond

 
 The default behavior is to append by a polymeric connection to the preceding residue
 If we want to connect via a non-polymer connection, we give the connection number, anchor residue
 and the connection number for the anchor residue. These connection numbers are wrt the connections_
 arrays in Residue and ResidueType

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

5. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int, anchor_residue : int, anchor_connection : int) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond

 
 The default behavior is to append by a polymeric connection to the preceding residue
 If we want to connect via a non-polymer connection, we give the connection number, anchor residue
 and the connection number for the anchor residue. These connection numbers are wrt the connections_
 arrays in Residue and ResidueType

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

6. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int, anchor_residue : int, anchor_connection : int, start_new_chain : bool) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond

 
 The default behavior is to append by a polymeric connection to the preceding residue
 If we want to connect via a non-polymer connection, we give the connection number, anchor residue
 and the connection number for the anchor residue. These connection numbers are wrt the connections_
 arrays in Residue and ResidueType

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

7. append_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, build_ideal_geometry : bool, connection : int, anchor_residue : int, anchor_connection : int, start_new_chain : bool, lookup_bond_length : bool) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new bond

 
 The default behavior is to append by a polymeric connection to the preceding residue
 If we want to connect via a non-polymer connection, we give the connection number, anchor residue
 and the connection number for the anchor residue. These connection numbers are wrt the connections_
 arrays in Residue and ResidueType

 If build_ideal_bond is TRUE it will transform the coordinates of the new residue so that the bond
 geometry of the new bond is ideal according to the icoor_internal data in the residues.

 Otherwise the incoming coordinates of new_rsd are preserved.

append_residue_by_jump(*args, **kwargs)

  
Overloaded function.

1. append_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, jump_anchor_residue : int) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new jump

2. append_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, jump_anchor_residue : int, jump_anchor_atom : unicode) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new jump

3. append_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, jump_anchor_residue : int, jump_anchor_atom : unicode, jump_root_atom : unicode) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new jump

4. append_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, jump_anchor_residue : int, jump_anchor_atom : unicode, jump_root_atom : unicode, start_new_chain : bool) -> NoneType

Appends  <new_rsd>  (a residue) to pose by a new jump

apply_transform_Rx_plus_v(...)

  
apply_transform_Rx_plus_v(self : rosetta.core.pose.Pose, R : rosetta.numeric.xyzMatrix_double_t, v : rosetta.numeric.xyzVector_double_t) -> NoneType

Apply a transform of the Rx + v form, where R is a
 rotation matrix and v is a translation vector.

assign(...)

  
assign(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose) -> rosetta.core.pose.Pose

Copies <src> into the pose where it remains possible that two
 Poses may point to each other in non-const ways or share non-bitwise
 constant data between them (E.g. the AtomTree observer system).

 example(s):
     test_pose.assign(pose)
 See also:
     Pose

batch_get_xyz(...)

 

batch_get_xyz(self : rosetta.core.pose.Pose, ids : rosetta.utility.vector1_core_id_AtomID, points : rosetta.utility.vector1_numeric_xyzVector_double_t) -> NoneType

Gets the locations (xyz) of pose AtomIDs in <ids>

batch_set_xyz(...)

  
batch_set_xyz(self : rosetta.core.pose.Pose, ids : rosetta.utility.vector1_core_id_AtomID, points : rosetta.utility.vector1_numeric_xyzVector_double_t) -> NoneType

Sets the locations (xyz) of pose AtomIDs in  <ids>
 to mathcing PointPositions in  <points>

beta(...)

  
beta(self : rosetta.core.pose.Pose, seqpos : int) -> float

Returns the beta torsion angle of residue  <seqpos>
 

 assumes the residue is an nucleic acid

 example(s):
     pose.beta(2)
 See also:
     Pose
     Pose.residue
     Pose.set_beta
     Residue

chain(...)

  
chain(self : rosetta.core.pose.Pose, seqpos : int) -> int

Returns the chain number of residue  <seqpos>

 example(s):
     pose.chain(3)
 See also:
     Pose
     Pose.annotated_sequence
 Pose.chain_sequence
     Pose.fold_tree
     Pose.sequence
     FoldTree

chain_sequence(...)

  
chain_sequence(self : rosetta.core.pose.Pose, chain_in : int) -> unicode

Returns the sequence for the chain <chain_in>

 Example(s):
     pose.chain_sequence(1)
 See also:
     Pose
     Pose.chain
     Pose.residue
     Pose.sequence

chi(*args, **kwargs)

  
Overloaded function.

1. chi(self : rosetta.core.pose.Pose, chino : int, seqpos : int) -> float

Returns the  <chino>  chi torsion angle of residue  <seqpos>
 

 assumes the residue is an amino acid or monosaccharide

 example(s):
     pose.chi(1,7)
 See also:
     Pose
     Pose.set_chi
     Pose.residue
     Residue

2. chi(self : rosetta.core.pose.Pose, seqpos : int) -> float

Returns the chi torsion angle of residue  <seqpos>
 

 assumes the residue is an nucleic acid

 example(s):
     pose.chi(7)
 See also:
     Pose
     Pose.residue
     Pose.set_chi
     Residue

clear(rosetta.core.pose.Pose)

  
Empty the pose contents

 example(s):
     pose.clear()
 See also:
     Pose
     Pose.assign
     Pose.empty
Returns: NoneType

conformation(*args, **kwargs)

  
Overloaded function.

1. conformation(rosetta.core.pose.Pose) -> rosetta.core.conformation.Conformation

Returns the pose Conformation (const-access)

 example(s):
     pose.Conformation()
 See also:
     Pose
     Conformation

2. conformation(rosetta.core.pose.Pose) -> rosetta.core.conformation.Conformation

Returns the pose Conformation (non-const access)

conformation_ptr(*args, **kwargs)

  
Overloaded function.

1. conformation_ptr(rosetta.core.pose.Pose) -> rosetta.core.conformation.Conformation

Returns the pose Conformation pointer (const access)

2. conformation_ptr(rosetta.core.pose.Pose) -> rosetta.core.conformation.Conformation

Returns the pose Conformation pointer (const access)
 

 WHOA: This is not cool.  The Pose cannot hand out access to the OP directly. Do not use.

constraint_set(*args, **kwargs)

  
Overloaded function.

1. constraint_set(rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet

2. constraint_set(self : rosetta.core.pose.Pose,  : core::scoring::constraints::ConstraintSet) -> NoneType

copy_segment(...)

  
copy_segment(self : rosetta.core.pose.Pose, size : int, src : rosetta.core.pose.Pose, begin : int, src_begin : int) -> NoneType

Copy a stretch of coordinates/torsions from  <src>
 to pose

corresponding_residue_in_current(...)

  
corresponding_residue_in_current(self : rosetta.core.pose.Pose, ref_residue_index : int, ref_pose_name : unicode) -> int

Returns the index of a residue in this pose corresponding to a residue in a reference pose.
 

 Throws an error if the reference pose with the given name doesn't exist, or the residue number
 doesn't exist in that reference pose.  Returns zero if no corresponding residue exists in this pose (e.g.
 if the residue in question has been deleted.

data(*args, **kwargs)

  
Overloaded function.

1. data(rosetta.core.pose.Pose) -> rosetta.basic.datacache.BasicDataCache

BasicDataCache indexed by enum in core/pose/datacache/CacheableDataType.hh

2. data(rosetta.core.pose.Pose) -> rosetta.basic.datacache.BasicDataCache

BasicDataCache indexed by enum in core/pose/datacache/CacheableDataType.hh

decrement_reference_pose_mapping_after_seqpos(...)

  
decrement_reference_pose_mapping_after_seqpos(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType

Find all mappings in the new pose after seqpos in all ReferencePose objects, and decrement them by 1.
 

 If there is no ReferencePose object, do nothing.

delete_polymer_residue(...)

  
delete_polymer_residue(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType

Delete a residue in the pose.
  Update Observers.
  Update any Reference Poses

delete_residue_range_slow(...)

  
delete_residue_range_slow(self : rosetta.core.pose.Pose, start : int, end : int) -> NoneType

Delete a range of residues in the pose.
 

 Calls confromation::delete_residue_range_slow().
  Update Observers.
  Update any Reference Poses

delete_residue_slow(...)

  
delete_residue_slow(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType

Slow method that relies on FoldTree::delete_seqpos, rebuilds atomtree, can handle jumps/root residue.
  Update Observers.
  Update any Reference Poses

delta(...)

  
delta(self : rosetta.core.pose.Pose, pos : int) -> float

Returns the delta torsion angle of residue  <seqpos>
 

 assumes the residue is an nucleic acid

 example(s):
     pose.delta(4)
 See also:
     Pose
     Pose.residue
     Pose.set_delta
     Residue

detached_copy(...)

  
detached_copy(self : rosetta.core.pose.Pose, src : rosetta.core.pose.Pose) -> NoneType

Performs a deep copy of the src Pose into this Pose in a way
 that guarantees that no non-bitwise-constant data is shared between
 them (such as the AtomTree's observer system) -- this Pose will be
 effectively detached from any data that lives in other objects.

dof(...)

  
dof(self : rosetta.core.pose.Pose, id : rosetta.core.id.DOF_ID) -> float

Returns the value of the AtomTree DOF  <id>

 See also:
     Pose
     DOF_ID

dump_cif(...)

  
dump_cif(self : rosetta.core.pose.Pose, file_name : unicode) -> NoneType

Export pose data to the mmCIF file  <file_name>

 example(s):
     pose.dump_cif('new_01.cif')
 See also:
     Pose
     pose_from_cif
     dump_file

dump_file(...)

  
dump_file(self : rosetta.core.pose.Pose, file_name : unicode) -> NoneType

Export pose data to a file, <file_name>, determining which type of file format to write based on the file extension

 example(s):
     pose.dump_file('new_01.pdb')
     pose.dump_file('new_01.cif')
 See also:
     Pose
     dump_cif
     dump_file

dump_pdb(*args, **kwargs)

  
Overloaded function.

1. dump_pdb(self : rosetta.core.pose.Pose, file_name : unicode) -> bool

Export pose data to the PDB file  <file_name>

 example(s):
     pose.dump_pdb('new_01.pdb')
 See also:
     Pose
     pose_from_pdb
     dump_cif
     dump_file

2. dump_pdb(self : rosetta.core.pose.Pose, file_name : unicode, tag : unicode) -> bool

Export pose data to the PDB file  <file_name>

 example(s):
     pose.dump_pdb('new_01.pdb')
 See also:
     Pose
     pose_from_pdb
     dump_cif
     dump_file

dump_scored_pdb(*args, **kwargs)

  
Overloaded function.

1. dump_scored_pdb(self : rosetta.core.pose.Pose, file_name : unicode, scorefxn : core::scoring::ScoreFunction) -> NoneType

Export pose data to the PDB file  <file_name>,
 add some score output

2. dump_scored_pdb(self : rosetta.core.pose.Pose, file_name : unicode, scorefxn : core::scoring::ScoreFunction, tag : unicode) -> NoneType

Export pose data to the PDB file  <file_name>,
 add some score output

empty(rosetta.core.pose.Pose)

  
Returns true if there are no residues in the conformation

 example(s):
     pose.empty()
 See also:
     Pose
     Pose.clear
 Pose.sequence
     Pose.total_residue
Returns: bool

energies(*args, **kwargs)

  
Overloaded function.

1. energies(rosetta.core.pose.Pose) -> core::scoring::Energies

////////////////////////////////////////
 

 Returns the pose Energies (const-access)

 example(s):
     pose.energies()
 See also:
     Pose
     Energies
     PDBInfo
     ScoreFunction
     create_score_function

2. energies(rosetta.core.pose.Pose) -> core::scoring::Energies

Returns the pose Energies (non-const access)

epsilon(...)

  
epsilon(self : rosetta.core.pose.Pose, seqpos : int) -> float

Returns the epsilon torsion angle of residue  <seqpos>
 

 assumes the residue is an nucleic acid

 example(s):
     pose.epsilon(5)
 See also:
     Pose
     Pose.residue
     Pose.set_epsilon
     Residue

fold_tree(*args, **kwargs)

  
Overloaded function.

1. fold_tree(rosetta.core.pose.Pose) -> rosetta.core.kinematics.FoldTree

Returns the pose FoldTree

 example(s):
     pose.fold_tree()
 See also:
     Pose
     FoldTree

2. fold_tree(self : rosetta.core.pose.Pose, fold_tree_in : rosetta.core.kinematics.FoldTree) -> NoneType

Sets the pose FoldTree to  <fold_tree_in>

 example(s):
     pose.fold_tree( foldtree )
 See also:
     Pose
     pose.fold_tree
     FoldTree

gamma(...)

  
gamma(self : rosetta.core.pose.Pose, seqpos : int) -> float

Returns the gamma torsion angle of residue  <seqpos>
 

 assumes the residue is an nucleic acid

 example(s):
     pose.gamma(3)
 See also:
     Pose
     Pose.residue
     Pose.set_gamma
     Residue

get_self_ptr(*args, **kwargs)

  
Overloaded function.

1. get_self_ptr(rosetta.core.pose.Pose) -> rosetta.core.pose.Pose

self pointers

2. get_self_ptr(rosetta.core.pose.Pose) -> rosetta.core.pose.Pose

get_self_weak_ptr(*args, **kwargs)

  
Overloaded function.

1. get_self_weak_ptr(rosetta.core.pose.Pose) -> rosetta.std.weak_ptr_const_core_pose_Pose_t

2. get_self_weak_ptr(rosetta.core.pose.Pose) -> rosetta.std.weak_ptr_core_pose_Pose_t

has_dof(...)

  
has_dof(self : rosetta.core.pose.Pose, id : rosetta.core.id.DOF_ID) -> bool

Returns true if pose has DOF  <id>

 See also:
     Pose
     DOF_ID

increment_reference_pose_mapping_after_seqpos(...)

  
increment_reference_pose_mapping_after_seqpos(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType

Find all mappings in the new pose after seqpos in all ReferencePose objects, and increment them by 1.
 

 If there is no ReferencePose object, do nothing.

insert_residue_by_bond(*args, **kwargs)

  
Overloaded function.

1. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int) -> NoneType

This code sorely belongs in Pose.cc
 

 Adds  <new_rsd_in>  to pose at  <seqpos>

2. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool) -> NoneType

This code sorely belongs in Pose.cc
 

 Adds  <new_rsd_in>  to pose at  <seqpos>

3. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool, anchor_atom : unicode) -> NoneType

This code sorely belongs in Pose.cc
 

 Adds  <new_rsd_in>  to pose at  <seqpos>

4. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool, anchor_atom : unicode, root_atom : unicode) -> NoneType

This code sorely belongs in Pose.cc
 

 Adds  <new_rsd_in>  to pose at  <seqpos>

5. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool, anchor_atom : unicode, root_atom : unicode, new_chain : bool) -> NoneType

This code sorely belongs in Pose.cc
 

 Adds  <new_rsd_in>  to pose at  <seqpos>

6. insert_residue_by_bond(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, build_ideal_geometry : bool, anchor_atom : unicode, root_atom : unicode, new_chain : bool, lookup_bond_length : bool) -> NoneType

This code sorely belongs in Pose.cc
 

 Adds  <new_rsd_in>  to pose at  <seqpos>

insert_residue_by_jump(*args, **kwargs)

  
Overloaded function.

1. insert_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int) -> NoneType

This code sorely belongs in Pose.cc
 

 Adds  <new_rsd_in>  to pose at  <seqpos>

2. insert_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, anchor_atomno : unicode) -> NoneType

This code sorely belongs in Pose.cc
 

 Adds  <new_rsd_in>  to pose at  <seqpos>

3. insert_residue_by_jump(self : rosetta.core.pose.Pose, new_rsd_in : rosetta.core.conformation.Residue, seqpos : int, anchor_pos : int, anchor_atomno : unicode, root_atomno : unicode) -> NoneType

This code sorely belongs in Pose.cc
 

 Adds  <new_rsd_in>  to pose at  <seqpos>

is_centroid(rosetta.core.pose.Pose)

  
Returns true if pose is ResidueType centroid

 
 convenience test for residue_type_set ( based on two
 middle residue -- to avoid hitting on ligands or pseudos )

 example(s):
     pose.is_centroid()
 See also:
     Pose
     Pose.is_fullatom
     Residue
     ResidueType
 

 this is nt a good test --Doug
Returns: bool

is_fullatom(rosetta.core.pose.Pose)

  
Returns true if pose is ResidueType fullatom

 
 convenience test for residue_type_set ( based on two
 middle residue -- to avoid hitting on ligands or pseudos )

 example(s):
     pose.is_fullatom()
 See also:
     Pose
     Pose.is_centroid
     Residue
     ResidueType
 

 this is nt a good test --Doug
Returns: bool

jump(*args, **kwargs)

  
Overloaded function.

1. jump(self : rosetta.core.pose.Pose, jump_number : int) -> rosetta.core.kinematics.Jump

Returns the pose FoldTree Jump  <jump_number>

 example(s):
     pose.jump(1)
 See also:
     Pose
     Pose.fold_tree
     Pose.set_jump
     FoldTree
     FoldTree.jump_edge
     Jump

2. jump(self : rosetta.core.pose.Pose, id : rosetta.core.id.AtomID) -> rosetta.core.kinematics.Jump

Returns the pose FoldTree Jump  <id>

 example(s):
     pose.set_jump(R5N)
 See also:
     Pose
     Pose.fold_tree
     Pose.set_jump
     FoldTree
     FoldTree.jump_edge
     AtomID

n_residue(rosetta.core.pose.Pose)

  
Returns the number of residues in the pose conformation
 example(s):
     pose.n_residue()
 See also:
     Pose
     Pose.sequence
     Pose.total_residue
Returns: int

num_jump(rosetta.core.pose.Pose)

  
Returns the number of jumps in the pose FoldTree

 example(s):
     pose.num_jump()
 See also:
     Pose
     Pose.jump
     Pose.set_jump
     FoldTree
     Jump
Returns: int

observer_cache(*args, **kwargs)

  
Overloaded function.

1. observer_cache(rosetta.core.pose.Pose) -> core::pose::datacache::ObserverCache

ObserverCache indexed by enum in core/pose/datacache/CacheableObserverType.hh

2. observer_cache(rosetta.core.pose.Pose) -> core::pose::datacache::ObserverCache

ObserverCache indexed by enum in core/pose/datacache/CacheableObserverType.hh

omega(...)

  
omega(self : rosetta.core.pose.Pose, seqpos : int) -> float

Returns the omega torsion angle of residue  <seqpos>
 

 assumes the residue is an amino acid or monosaccharide

 example(s):
     pose.omega(3)
 See also:
     Pose
     Pose.residue
     Pose.set_omega
     Residue

pdb_info(*args, **kwargs)

  
Overloaded function.

1. pdb_info(rosetta.core.pose.Pose) -> core::pose::PDBInfo

Returns the pose PDBInfo (const)

 example(s):
     pose.pdb_info()
 See also:
     Pose
     Energies
     PDBInfo
 ScoreFunction
 pose_from_pdb
 

 NULL if no PDBInfo instance exists, the pdb info instance otherwise

2. pdb_info(rosetta.core.pose.Pose) -> core::pose::PDBInfo

Returns the pose PDBInfo
 

 NULL if no PDBInfo instance exists, the PDBInfo instance otherwise

3. pdb_info(self : rosetta.core.pose.Pose, new_info : core::pose::PDBInfo) -> core::pose::PDBInfo

Sets pose PDBInfo to <new_info>
 

  the new PDBInfo to copy, pass NULL
 if you want to zero the existence of PDBInfo inside this Pose
 

 the prior PDBInfo instance

phi(...)

  
phi(self : rosetta.core.pose.Pose, seqpos : int) -> float

Returns the phi torsion angle of residue  <seqpos>
 

 assumes the residue is an amino acid or monosaccharide

 example(s):
     pose.phi(1)
 See also:
     Pose
     Pose.residue
     Pose.set_phi
     Residue

prepend_polymer_residue_before_seqpos(...)

 

prepend_polymer_residue_before_seqpos(self : rosetta.core.pose.Pose, new_rsd : rosetta.core.conformation.Residue, seqpos : int, build_ideal_geometry : bool) -> NoneType

glues to seqpos and perhaps also seqpos-1

psi(...)

  
psi(self : rosetta.core.pose.Pose, seqpos : int) -> float

Returns the psi torsion angle of residue  <seqpos>
 Note: assumes the residue is an amino acid or monosaccharide

 example(s):
     pose.psi(2)
 See also:
     Pose
     Pose.residue
     Pose.set_psi
     Residue

reference_pose_from_current(*args, **kwargs)

  
Overloaded function.

1. reference_pose_from_current(self : rosetta.core.pose.Pose, ref_pose_name : unicode) -> NoneType

Create a new reference pose from the current state of the pose.
 

 If a ReferencePoseSet object does not exist, this function will create it.
  If override_current is set to true, will override any currently set reference pose with the ref_pose_name.

2. reference_pose_from_current(self : rosetta.core.pose.Pose, ref_pose_name : unicode, override_current : bool) -> NoneType

Create a new reference pose from the current state of the pose.
 

 If a ReferencePoseSet object does not exist, this function will create it.
  If override_current is set to true, will override any currently set reference pose with the ref_pose_name.

reference_pose_set(rosetta.core.pose.Pose)

  
Access the ReferencePoseSet object (non-const).
 

 If a ReferencePoseSet object does not exist, this function will create it.
Returns: core::pose::reference_pose::ReferencePoseSet

reference_pose_set_cop(rosetta.core.pose.Pose)

  
Const-access the ReferencePoseSet object.
 

 If a ReferencePoseSet object does not exist, this function will throw an error.
Returns: core::pose::reference_pose::ReferencePoseSet

remove_constraint(*args, **kwargs)

  
Overloaded function.

1. remove_constraint(self : rosetta.core.pose.Pose, cst : core::scoring::constraints::Constraint) -> bool

re object_comparison see comment for ConstraintSet::remove_constraint function

2. remove_constraint(self : rosetta.core.pose.Pose, cst : core::scoring::constraints::Constraint, object_comparison : bool) -> bool

re object_comparison see comment for ConstraintSet::remove_constraint function

remove_constraints(*args, **kwargs)

  
Overloaded function.

1. remove_constraints(self : rosetta.core.pose.Pose, csts : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> bool

re object_comparison see comment for ConstraintSet::remove_constraint function

2. remove_constraints(self : rosetta.core.pose.Pose, csts : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, object_comparison : bool) -> bool

re object_comparison see comment for ConstraintSet::remove_constraint function

3. remove_constraints(rosetta.core.pose.Pose) -> bool

replace_residue(*args, **kwargs)

  
Overloaded function.

1. replace_residue(self : rosetta.core.pose.Pose, seqpos : int, new_rsd_in : rosetta.core.conformation.Residue, orient_backbone : bool) -> NoneType

Replaces the residue at  <seqpos>  with  <new_rsd_in>

2. replace_residue(self : rosetta.core.pose.Pose, seqpos : int, new_rsd_in : rosetta.core.conformation.Residue, atom_pairs : rosetta.utility.vector1_std_pair_std_string_std_string_t) -> NoneType

Replaces the residue at  <seqpos>  with  <new_rsd>
 based on superposition on the specified input atom pairs
 NOTE: at the moment, only superposition on 3 atoms works
 This code sorely belongs in Pose.cc

residue(...)

  
residue(self : rosetta.core.pose.Pose, seqpos : int) -> rosetta.core.conformation.Residue

Returns the Residue at position  <seqpos>  (read access)
 Note: this method will trigger a refold if either the
 torsions or the coordinates are out-of-date

 example(s):
     pose.residue(4)
 See also:
     Pose
     Pose.sequence
     Pose.total_residue
     Residue
     ResidueType

residue_type(...)

  
residue_type(self : rosetta.core.pose.Pose, seqpos : int) -> rosetta.core.chemical.ResidueType

Returns the ResidueType at position  <seqpos>  (read access)
 Note: this method NOT will trigger a refold if either
 the torsions or the coordinates are out-of-date

 example(s):
     pose.residue_type(5)
 See also:
     Pose
     Pose.residue
     Pose.sequence
     Pose.total_residue
     Residue
     ResidueType

scoring_begin(...)

 

scoring_begin(self : rosetta.core.pose.Pose, info : core::scoring::ScoreFunction) -> NoneType

Called by ScoreFunction at the beginning of scoring

scoring_end(...)

 

scoring_end(self : rosetta.core.pose.Pose, scorefxn : core::scoring::ScoreFunction) -> NoneType

Called by ScoreFunction at the end of scoring

secstruct(*args, **kwargs)

  
Overloaded function.

1. secstruct(self : rosetta.core.pose.Pose, seqpos : int) -> unicode

Returns the secondary structure of residue  <seqpos>
 this usually comes from fragments. The conformation object
 will not invoke DSSP to determine the secondary structure
 if e.g. it has not been made from fragments.
 'H' = helical
 'S' = strand or sheet
 'E' = loop
 JKL: is this correct? DsspDesignOperations says that
 H = helix, E = strand, and L = loop

 example(s):
     pose.secstruct(3)
 See also:
     Pose
     Pose.residue
     Pose.set_secstruct
     Residue

2. secstruct(rosetta.core.pose.Pose) -> unicode

Returns a string representing pose secondary structure

 example(s):
     pose.secstruct()
 See also:
     Pose
     Pose.residue
     Pose.set_secstruct
     Residue

sequence(*args, **kwargs)

  
Overloaded function.

1. sequence(rosetta.core.pose.Pose) -> unicode

Returns a string representing the 1-letter-coded sequence of the pose conformation.

 example(s):
     pose.sequence()
 See also:
     Pose
     Pose.annotated_sequence
     Pose.chain
     Pose.chain_sequence
     Pose.residue
     Pose.total_residue

2. sequence(self : rosetta.core.pose.Pose, resnum_start : int, resnum_end : int) -> unicode

Returns a string representing the 1-letter-coded sequence of the pose conformation. From start to end.

 example(s):
     pose.sequence()
 See also:
     Pose
     Pose.annotated_sequence
     Pose.chain
     Pose.chain_sequence
     Pose.residue
     Pose.total_residue

set_alpha(...)

  
set_alpha(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the alpha torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an nucleic acid

 example(s):
     pose.set_alpha(1)
 See also:
     Pose
     Pose.alpha
     Pose.residue
     Residue

set_beta(...)

  
set_beta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the beta torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an nucleic acid

 example(s):
     pose.set_beta(2)
 See also:
     Pose
     Pose.beta
     Pose.residue
     Residue

set_chi(*args, **kwargs)

  
Overloaded function.

1. set_chi(self : rosetta.core.pose.Pose, chino : int, seqpos : int, setting : float) -> NoneType

Sets the  <chino>  chi torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an amino acid or monosaccharide

 example(s):
     pose.set_chi(1,7,120)
 See also:
     Pose
     Pose.chi
     Pose.residue
     Residue

2. set_chi(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the chi torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an nucleic acid

 example(s):
     pose.set_chi(7)
 See also:
     Pose
     Pose.chi
     Pose.residue
     Residue

set_delta(...)

  
set_delta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the delta torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an nucleic acid

 example(s):
     pose.set_delta(4)
 See also:
     Pose
     Pose.delta
     Pose.residue
     Residue

set_dof(...)

  
set_dof(self : rosetta.core.pose.Pose, id : rosetta.core.id.DOF_ID, setting : float) -> NoneType

Sets the value of the AtomTree DOF  <id>

 See also:
     Pose
     DOF_ID

set_epsilon(...)

  
set_epsilon(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the epsilon torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an nucleic acid

 example(s):
     pose.set_epsilon(5)
 See also:
     Pose
     Pose.epsilon
     Pose.residue
     Residue

set_gamma(...)

  
set_gamma(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the gamma torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an nucleic acid

 example(s):
     pose.set_gamma(3)
 See also:
     Pose
     Pose.gamma
     Pose.residue
     Residue

set_jump(*args, **kwargs)

  
Overloaded function.

1. set_jump(self : rosetta.core.pose.Pose, jump_number : int, new_jump : rosetta.core.kinematics.Jump) -> NoneType

Sets the pose FoldTree Jump  <jump_number>  to  <new_jump>

 example(s):
     pose.set_jump(1,jump1)
 See also:
     Pose
     Pose.fold_tree
     Pose.jump
     FoldTree
     FoldTree.jump_edge
     Jump

2. set_jump(self : rosetta.core.pose.Pose, id : rosetta.core.id.AtomID, new_jump : rosetta.core.kinematics.Jump) -> NoneType

Sets the pose FoldTree Jump  <id>  to  <new_jump>

 example(s):
     pose.set_jump(1,jump1)
 See also:
     Pose
     Pose.fold_tree
     Pose.jump
     FoldTree
     FoldTree.jump_edge
     AtomID

set_new_conformation(...)

  
set_new_conformation(self : rosetta.core.pose.Pose, new_conformation : rosetta.core.conformation.Conformation) -> NoneType

Now that the conformation_ member data is an owning pointer,
 and we have derived classes of Conformation.

set_new_energies_object(...)

  
set_new_energies_object(self : rosetta.core.pose.Pose, energies : core::scoring::Energies) -> NoneType

Now that the energies_ member data is an owning pointer,
 and we have derived classes of Energies.

set_omega(...)

  
set_omega(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the omega torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an amino acid or monosaccharide

 example(s):
     pose.set_omega(3, 180.0)
 See also:
     Pose
     Pose.omega
     Pose.residue
     Residue

set_phi(...)

  
set_phi(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the phi torsion angle of residue  <seqpos> to  <setting>
 

  <setting>  must be in degrees, assumes residue is an amino acid or monosaccharide

 example(s):
     pose.set_phi(1, -23.7)
 See also:
     Pose
     Pose.phi
     Pose.residue
     Residue

set_psi(...)

  
set_psi(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the psi torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an amino acid or monosaccharide

 example(s):
     pose.set_psi(2, 45.3)
 See also:
     Pose
     Pose.psi
     Pose.residue
     Residue

set_ring_conformation(...)

 

set_ring_conformation(self : rosetta.core.pose.Pose, seqpos : int, ring_num : int, conformer : rosetta.core.chemical.rings.RingConformer) -> NoneType

Set the given residue and ring's ring conformation, if appropriate.

set_secstruct(...)

  
set_secstruct(self : rosetta.core.pose.Pose, seqpos : int, setting : unicode) -> NoneType

Assign the secondary structure of residue  <seqpos> to  <setting>

 example(s):
     pose.set_secstruct(3,'H')
 See also:
     Pose
     Pose.residue
     Pose.secstruct
     Residue

set_theta(...)

  
set_theta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the theta torsion angle of beta-amino acid residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is a beta-amino acid.

 example(s):
     pose.set_theta(21, 58.9)
 See also:
     Pose
     Pose.theta
     Pose.residue
     Residue
 

 Vikram K. Mulligan (vmullig.edu)

set_torsion(...)

  
set_torsion(self : rosetta.core.pose.Pose, id : core::id::TorsionID, setting : float) -> NoneType

Sets the Conformation torsion angle identified
 by  <id>  to  <setting>

 See also:
     Pose
     TorsionID

set_xyz(*args, **kwargs)

  
Overloaded function.

1. set_xyz(self : rosetta.core.pose.Pose, id : rosetta.core.id.AtomID, point : rosetta.numeric.xyzVector_double_t) -> NoneType

Sets the location (xyz) of pose AtomID  <id>  to
 the PointPosition  <point>

 See also:
     Pose
     Pose.residue
     Pose.xyz
     Residue

2. set_xyz(self : rosetta.core.pose.Pose, id : rosetta.core.id.NamedAtomID, point : rosetta.numeric.xyzVector_double_t) -> NoneType

Sets the location (xyz) of pose NamedAtomID  <id>
 to the PointPosition  <point>

 See also:
     Pose
     Pose.residue
     Pose.xyz
     Residue

set_zeta(...)

  
set_zeta(self : rosetta.core.pose.Pose, seqpos : int, setting : float) -> NoneType

Sets the zeta torsion angle of residue  <seqpos>  to  <setting>
 

  <setting>  must be in degrees, assumes residue is an nucleic acid

 example(s):
     pose.set_zeta(6)
 See also:
     Pose
     Pose.zeta
     Pose.residue
     Residue

split_by_chain(*args, **kwargs)

  
Overloaded function.

1. split_by_chain(rosetta.core.pose.Pose) -> rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t

Returns a vector of poses with one element per chain of the original pose

2. split_by_chain(self : rosetta.core.pose.Pose, chain_id : int) -> rosetta.core.pose.Pose

theta(...)

  
theta(self : rosetta.core.pose.Pose, seqpos : int) -> float

Returns the theta torsion angle of beta-amino acid residue  <seqpos>
 

  assumes residue is a beta-amino acid.

 example(s):
     pose.theta(21)
 See also:
     Pose
     Pose.set_theta
     Pose.residue
     Residue
 

 Vikram K. Mulligan (vmullig.edu)

torsion(...)

  
torsion(self : rosetta.core.pose.Pose, id : core::id::TorsionID) -> float

Returns the Conformation torsion angle identified by  <id>

 See also:
     Pose
     TorsionID

total_atoms(*args, **kwargs)

  
Overloaded function.

1. total_atoms(rosetta.core.pose.Pose) -> int

Returns the total number of atoms in the pose conformation
 example:
   pose.total_atoms()

2. total_atoms(self : rosetta.core.pose.Pose, nres : int) -> int

Returns the total number of atoms in the pose
 up to a particular residue

total_residue(rosetta.core.pose.Pose)

  
Returns the number of residues in the pose conformation

 example(s):
     pose.total_residue()
 See also:
     Pose
     Pose.n_residue
     Pose.sequence
Returns: int

update_actcoord(...)

 

update_actcoord(self : rosetta.core.pose.Pose, resid : int) -> NoneType

Updates the action coordinates for pose residue <resid>

xyz(*args, **kwargs)

  
Overloaded function.

1. xyz(self : rosetta.core.pose.Pose, id : rosetta.core.id.AtomID) -> rosetta.numeric.xyzVector_double_t

Returns the location (xyz) of pose AtomID  <id>

 example(s):
     atom = AtomID(1,1)
     pose.xyz(atom)
 See also:
     Pose
     Pose.residue
     AtomID
     Residue
     Residue.xyz

2. xyz(self : rosetta.core.pose.Pose, id : rosetta.core.id.NamedAtomID) -> rosetta.numeric.xyzVector_double_t

Returns the location (xyz) of pose NamedAtomID  <id>

 Tutorial soon...
 See also:
     Pose
     Pose.residue
     NamedAtomID
     Residue
     Residue.xyz

zero_reference_pose_mapping_at_seqpos(...)

  
zero_reference_pose_mapping_at_seqpos(self : rosetta.core.pose.Pose, seqpos : int) -> NoneType

Find all mappings in the new pose to seqpos in all ReferencePose objects, and set them to point to residue 0 (deletion signal).
 

 If there is no ReferencePose object, do nothing.

zeta(...)

  
zeta(self : rosetta.core.pose.Pose, seqpos : int) -> float

Returns the zeta torsion angle of residue  <seqpos>
 

 assumes the residue is an nucleic acid

 example(s):
     pose.zeta(6)
 See also:
     Pose
     Pose.residue
     Pose.set_zeta
     Residue

   Home       Trees       Indices       Help   
Generated by Epydoc 3.0.1 on Fri Jul 29 19:29:07 2016 http://epydoc.sourceforge.net