Package rosetta :: Package core :: Package conformation :: Module _core_conformation_ :: Class Residue

Class Residue

 object --+    
          |    
??.instance --+
              |
             Residue

Instance Residue class, used for placed residues and rotamers
This class is designed to be lightweight.  It holds a const-reference ("rsd_type_")
to a ResidueType object for access to information common to all instances
of a single type, e.g., Alanine or Thymine.  Residue stores any data unique
to a placed residue or rotamer, currently:
- a vector1 of Atoms, which holds the positions (and also the atom-types for
        fast access during scoring);
- the sequence position and chain, both integers
- the backbone, side-chain, and internal ring (if applicable) torsion angles (of course backbone torsions are
        not unique to a rotamer, and the chi angles are derivable from the coordinates,
        but storing them in the residue is convenient for scoring purposes).
- the coordinates of an interaction center or centroid, used e.g., in the
        knowledge-based full-atom pair term ("actcoord_").  Maybe this will also
        hold the centroid position for centroid-mode scoring??

Instance Methods

[hide private]

Haro_index(...)
Haro_index( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of this residue's aromatic hydrogens : AtomIndices == vector1< Size > example(s): residue.Haro_index() See also: Residue Residue.atoms Residue.Hpol_index Pose

Hpol_index(...)
Hpol_index( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of this residue's polar hydrogens : AtomIndices == vector1< Size > example(s): residue.Hpol_index() See also: Residue Residue.atoms Residue.Hpol_index Residue.Hpos_apolar Residue.Hpos_polar Pose

Hpos_apolar(...)
Hpos_apolar( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of this residue's apolar hydrogens : AtomIndices == vector1< Size > example(s): residue.Hpos_apolar() See also: Residue Residue.atoms Residue.Hpol_index() Residue.Hpos_polar Pose

Hpos_polar(...)
Hpos_polar( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of this residue's polar hydrogens : AtomIndices == vector1< Size > example(s): residue.Hpos_polar() See also: Residue Residue.atoms Residue.Hpol_index Residue.Hpos_apolar Pose

Hpos_polar_sc(...)
Hpos_polar_sc( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of this residue's polar sidechain hydrogens : AtomIndices == vector1< Size > example(s): residue.Hpos_polar_sc() See also: Residue Residue.atoms Residue.Hpol_index Residue.Hpos_polar Pose

RNA_type(...)
RNA_type( (Residue)arg1) -> RNA_ResidueType : Return the RNA_residueType object.

__init__(...)
__init__( (object)arg1, (ResidueType)rsd_type_in, (bool)dummy_arg) -> None : constructors

__reduce__(...)
helper for pickle

__str__(...)
__str__( (Residue)arg1) -> object :

aa(...)
aa( (Residue)arg1) -> AA : Returns this residue's AA type, if any Used for knowledge-based scores, dunbrack, etc.

abase2(...)
abase2( (Residue)arg1, (int)atomno) -> int : Returns the atom index of the <atomno> atom's second base atom note: abase2 is this atom's first bonded neighbor other than this atom's base atom (unless it has only one neighbor)

accpt_pos(...)
accpt_pos( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of this residue's h-bond acceptor atoms : AtomIndices == vector1< Size > example(s): residue.accpt_pos() See also: Residue Residue.accpt_pos_sc Residue.atoms Pose

accpt_pos_sc(...)
accpt_pos_sc( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of this residue's sidechain h-bond acceptor atoms : AtomIndices == vector1< Size > example(s): residue.accpt_pos_sc() See also: Residue Residue.accpt_pos Residue.atoms Pose

actcoord(...)
actcoord( (Residue)arg1) -> xyzVector_Real : Returns the coordinates used for pairE calculations (amino acids only)

actcoord_atoms(...)
actcoord_atoms( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of atoms that will be used to define this residue's actcoord.

actual_residue_connection(...)
actual_residue_connection( (Residue)arg1, (int)resconnid) -> ResConnID : core/conformation/Residue.hh:1200

all_bb_atoms(...)
all_bb_atoms( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of this residue's backbone atoms : heavyatoms and hydrogens, AtomIndices == vector1< Size > example(s): residue.all_bb_atoms() See also: Residue Residue.atoms Pose

apply_transform_Rx_plus_v(...)
apply_transform_Rx_plus_v( (Residue)arg1, (xyzMatrix_Real)R, (xyzVector_Real)v) -> None : Applies a transform of the form Rx + v, where R is a rotation matrix, V is a vector, and x is the original position in xyz space

atom(...)
atom( (Residue)arg1, (int)atm_index) -> Atom : Returns this residue's Atom with index number <atm_index> (const) : Atom object is xyz and atom_type example(s): residue.atom(3) See also: Residue Residue.atoms Pose

atom_base(...)
atom_base( (Residue)arg1, (int)atomno) -> int : Returns the atom index of the <atomno> atom's base atom

atom_begin(...)
atom_begin( (Residue)arg1) -> object : begin interator, to iterate over atoms

atom_end(...)
atom_end( (Residue)arg1) -> object : end interator, to iterate over atoms

atom_index(...)
atom_index( (Residue)arg1, (str)atm) -> int : Returns the index number of the <atm> in this residue example: residue.atom_index("CA") returns 2 for a normal amino acid example(s): residue.atom_index("CA") See also: Residue AtomType Pose

atom_is_backbone(...)
atom_is_backbone( (Residue)arg1, (int)atomno) -> bool : Returns true if this residue's atom with index number <atomno> is a backbone atom example(s): residue.atom_is_backbone(3) See also: Residue Residue.all_bb_atoms Residue.atom Residue.atoms Pose

atom_is_hydrogen(...)
atom_is_hydrogen( (Residue)arg1, (int)atomno) -> bool : Returns true if this residue's atom with index number <atomno> is a hydrogen example(s): residue.atom_is_backbone(3) See also: Residue Residue.all_bb_atoms Residue.atom Residue.atoms Pose

atom_is_polar_hydrogen(...)
atom_is_polar_hydrogen( (Residue)arg1, (int)ind) -> bool : Is a particular atom a polar hydrogen?

atom_name(...)
atom_name( (Residue)arg1, (int)atm) -> str : ////////////////////////// Returns the name of this residue's atom with index number <atm>

atom_type(...)
atom_type( (Residue)arg1, (int)atomno) -> AtomType : /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ////////////// Atom Functions //////////////////////// ///////////////Atom Functions ///////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// Returns the AtomType of this residue's atom with index number <atomno>

atom_type_index(...)
atom_type_index( (Residue)arg1, (int)atomno) -> int : Returns the atom_type_index of this residue's atom with index number <atomno> atom_type_index is used to query this atom's AtomType from an AtomTypeSet, example: AtomTypeSet[atom_type_index] = AtomType example(s): residue.atom_type_index(3) See also: Residue Residue.atom_index AtomType Pose

atom_type_set(...)
atom_type_set( (Residue)arg1) -> AtomTypeSet : Returns the AtomTypeSet of this residue example(s): residue.atom_type_set() See also: Residue Residue.atom_type_index AtomType Pose

atomic_charge(...)
atomic_charge( (Residue)arg1, (int)atomno) -> float : Returns the atom charge of this residue's atom with index number <atomno> example(s): residue.atomic_charge(3) See also: Residue Residue.atom_index Pose

atoms(...)
atoms( (Residue)arg1) -> vector1_core_conformation_Atom : Returns this residue's Atoms (const), a vector1 of Atom objects example(s): residue.atoms() See also: Residue Pose

atoms_with_orb_index(...)
atoms_with_orb_index( (Residue)arg1) -> vector1_Size : /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ////////////// Orbital Functions ////////////////////// ///////////// Orbital Functions ////////////////////// /////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////

attached_H_begin(...)
attached_H_begin( (Residue)arg1, (int)atom) -> int : Returns the index number of the first hydrogen attached to the atom with index number <atom> example(s): residue.attached_H_begin() See also: Residue Residue.atom Residue.atoms Residue.attached_H_end Pose

attached_H_end(...)
attached_H_end( (Residue)arg1, (int)atom) -> int : Returns the index number of the last hydrogen attached to the atom with index number <atom> example(s): residue.attached_H_end() See also: Residue Residue.atom Residue.atoms Residue.attached_H_begin Pose

backbone_aa(...)
backbone_aa( (Residue)arg1) -> AA : Returns this residue's backbone_aa type, if any.

bonded_neighbor(...)
bonded_neighbor( (Residue)arg1, (int)atm) -> vector1_Size : Returns the AtomIndices for all bonded neighbor atoms of <atm>

bonded_orbitals(...)
bonded_orbitals( (Residue)arg1, (int)atm) -> vector1_Size : core/conformation/Residue.hh:1010

build_atom_ideal(...)
build_atom_ideal( (Residue)arg1, (int)atomno, (Conformation)conformation) -> xyzVector_Real : Return coordinates for building an atom from ideal internal coordinates, used for building missing atoms

build_orbital_xyz(...)
build_orbital_xyz( (Residue)arg1, (int)orbital_index) -> xyzVector_Real : core/conformation/Residue.hh:966

carbohydrate_info(...)
carbohydrate_info( (Residue)arg1) -> CarbohydrateInfo : Return the CarbohydrateInfo object containing sugar-specific properties for this residue.

chain(...)
chain( (Residue)arg1) -> int : Returns this residue's chain id

chi(...)
chi( (Residue)arg1) -> vector1_Real : Returns the chi torsion angles of this residue (const) example(s): residue.chi() See also: Residue Residue.nchi Pose Pose.chi

chi_atoms(...)
chi_atoms( (Residue)arg1) -> vec1_vec1_Size : Returns the AtomIndices of each set of four atoms defining each chi angle

chi_rotamers(...)
chi_rotamers( (Residue)arg1, (int)chino) -> vector1_pair_Real_Real : Returns the chi rotamers available for this residue's chi angle <chino>

clear_residue_connections(...)
clear_residue_connections( (Residue)arg1) -> None : core/conformation/Residue.hh:1175

clone(...)
clone( (Residue)arg1) -> Residue : Copy this residue( allocate actual memory for it )

connect_atom(...)
connect_atom( (Residue)arg1, (Residue)other) -> int : Returns the index number of this residue's atom connected to the <other> Residue example(s): See also: Residue Residue.atom Residue.atoms Residue.lower_connect_atom Residue.upper_connect_atom Pose

connect_map(...)
connect_map( (Residue)arg1, (int)resconn_index) -> ResConnID : core/conformation/Residue.hh:1165

connect_map_size(...)
connect_map_size( (Residue)arg1) -> int : Returns the size (number of elements) in the connect_map_ object.

connected_residue_at_resconn(...)
connected_residue_at_resconn( (Residue)arg1, (int)resconn_index) -> int : core/conformation/Residue.hh:1160

connection_distance(...)
connection_distance( (Residue)arg1, (Conformation)conf, (int)resconn_index, (xyzVector_Real)matchpoint) -> float : Distance between a potential residue connection match and the position of the expected atom

connection_incomplete(...)
connection_incomplete( (Residue)arg1, (int)resconnid) -> bool : core/conformation/Residue.hh:1197

connections_match(...)
connections_match( (Residue)arg1, (Residue)other) -> bool : Returns true if ???

connections_to_residue(...)
connections_to_residue( (Residue)arg1, (Residue)other) -> vector1_Size : Returns the vector1 of resconn ids that connect this residue to other

copy_residue_connections(...)
copy_residue_connections( (Residue)arg1, (Residue)src_rsd) -> None : attempt to take residue connection info from src_rsd

copy_residue_connections_from(...)
copy_residue_connections_from( (Residue)arg1, (Residue)src) -> None : core/conformation/Residue.hh:1185

create_residue(...)
create_residue( (Residue)arg1) -> Residue : Returns a ResidueOP for creating a copy of residue, same as clone() Temporary hack until Residue hierarchy is worked out

create_rotamer(...)
create_rotamer( (Residue)arg1) -> Residue : /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// ////////////// Residue Functions ////////////////////// ///////////// Residue Functions ////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// Returns a ResidueOP for creating a rotamer of this residue Temporary hack until Residue hierarchy is worked out

cut_bond_neighbor(...)
cut_bond_neighbor( (Residue)arg1, (int)atm) -> vector1_Size : atom indices for bonded neighbors to which atom-tree connections are disallowed.

data_ptr(...)
data_ptr( (Residue)arg1) -> BasicDataCache : BasicDataCache indexed by enum in residue_datacache.hh

fill_missing_atoms(...)
fill_missing_atoms( (Residue)arg1, (vector1_bool)missing, (Conformation)conformation) -> None : Builds coordinates for atoms missing from this residue assuming ideal internal coordinates

first_sidechain_atom(...)
first_sidechain_atom( (Residue)arg1) -> int : Returns the index number of the first sidechain heavyatom example(s): residue.first_sidechain_atom() See also: Residue Residue.atom Residue.atoms Residue.last_backbone_atom Pose

first_sidechain_hydrogen(...)
first_sidechain_hydrogen( (Residue)arg1) -> int : Returns the index number of the first sidechain hydrogen example(s): residue.first_sidechain_hydrogen() See also: Residue Residue.atom Residue.atoms Residue.first_sidechain_atom Pose

get_metal_binding_atoms(...)
get_metal_binding_atoms( (Residue)arg1, (vector1_Size)metal_binding_indices) -> None : Gets the AtomIndices of the atoms in this residue that can bind to metals : AtomIndices == vector1< Size > : Vikram K.

get_pseudobonds_to_residue(...)
get_pseudobonds_to_residue( (Residue)arg1, (int)resid) -> PseudoBondCollection : core/conformation/Residue.hh:1298

get_self_ptr(...)
get_self_ptr( (Residue)arg1) -> Residue : self pointers

get_self_weak_ptr(...)
get_self_weak_ptr( (Residue)arg1) -> ResidueCAP : core/conformation/Residue.hh:120

has(...)
has( (Residue)arg1, (str)atm) -> bool : Returns true if this residue has an atom named <atm>

has_incomplete_connection(...)
has_incomplete_connection( (Residue)arg1) -> bool : core/conformation/Residue.hh:1188

has_lower_connect(...)
has_lower_connect( (Residue)arg1) -> int : Returns true if residue has a valid lower connection.

has_property(...)
has_property( (Residue)arg1, (str)property) -> bool : Return true if the residue has <property>.

has_sc_orbitals(...)
has_sc_orbitals( (Residue)arg1) -> bool : Returns true if the residue has side chain orbitals

has_upper_connect(...)
has_upper_connect( (Residue)arg1) -> int : Returns true if residue has a valid upper connection.

has_variant_type(...)
has_variant_type( (Residue)arg1, (VariantType)variant_type) -> bool : Generic variant access

heavyAtoms_end(...)
heavyAtoms_end( (Residue)arg1) -> object : core/conformation/Residue.hh:465

heavyatom_has_polar_hydrogens(...)
heavyatom_has_polar_hydrogens( (Residue)arg1, (int)ind) -> bool : Is a particular atom a heavy atom with chemically bound polar hydrogens? (i.e.

heavyatom_is_an_acceptor(...)
heavyatom_is_an_acceptor( (Residue)arg1, (int)ind) -> bool : Is a particular atom a heavy atom acceptor?

icoor(...)
icoor( (Residue)arg1, (int)atm) -> AtomICoor : Returns the internal coordinates of this residue's atom with index number <atm>

is_DNA(...)
is_DNA( (Residue)arg1) -> bool : Returns true if this residue is a DNA residue

is_NA(...)
is_NA( (Residue)arg1) -> bool : Returns true if this residue is a nucleic acid

is_RNA(...)
is_RNA( (Residue)arg1) -> bool : Returns true if this residue is a RNA residue

is_apolar(...)
is_apolar( (Residue)arg1) -> bool : Returns true if the residue is apolar : apolar is classified as NOT polar, aromatic, or charged

is_aromatic(...)
is_aromatic( (Residue)arg1) -> bool : Returns true if the residue is aromatic

is_bonded(...)
is_bonded( (Residue)arg1, (Residue)other) -> bool : Am I bonded to other? Meaningful for arbitrary topologies (e.g.

is_branch_lower_terminus(...)
is_branch_lower_terminus( (Residue)arg1) -> bool : Return true if the residue is a branch lower terminus variant.

is_branch_point(...)
is_branch_point( (Residue)arg1) -> bool : Return true if the residue is a branch point variant.

is_carbohydrate(...)
is_carbohydrate( (Residue)arg1) -> bool : Returns true if this residue is a carbohydrate

is_charged(...)
is_charged( (Residue)arg1) -> bool : Returns true if the residue is charged

is_coarse(...)
is_coarse( (Residue)arg1) -> bool : residue is coarse (used for RNA right now)

is_ligand(...)
is_ligand( (Residue)arg1) -> bool : Returns true if this residue is a ligand

is_lower_terminus(...)
is_lower_terminus( (Residue)arg1) -> bool : Returns true if the residue has a lower terminus variant

is_metal(...)
is_metal( (Residue)arg1) -> bool : Returns true if this residue is a metal ion, false otherwise.

is_metalbinding(...)
is_metalbinding( (Residue)arg1) -> bool : Returns true if this residue is a type capable of binding to a metal ion (e.g.

is_peptoid(...)
is_peptoid( (Residue)arg1) -> bool : Returns if this residue is a peptoid

is_polar(...)
is_polar( (Residue)arg1) -> bool : Returns true if the residue is polar

is_polymer(...)
is_polymer( (Residue)arg1) -> bool : ////////// Returns true if this residue is a polymer

is_polymer_bonded(...)
is_polymer_bonded( (Residue)arg1, (Residue)other) -> bool : Am I polymer bonded to other?

is_protein(...)
is_protein( (Residue)arg1) -> bool : Returns true if this residue is an amino acid

is_pseudo_bonded(...)
is_pseudo_bonded( (Residue)arg1, (Residue)other) -> bool : Do I have any pseudobonds to other?

is_similar_aa(...)
is_similar_aa( (Residue)arg1, (Residue)other) -> bool : Returns true if the aa residue types are the same

is_similar_rotamer(...)
is_similar_rotamer( (Residue)arg1, (Residue)other) -> bool : Returns true if the chi angles of another residue all fall within 5 deg

is_sri(...)
is_sri( (Residue)arg1) -> bool : Is this one of SRI's special heteropolymer building blocks?

is_surface(...)
is_surface( (Residue)arg1) -> bool : Returns true if this residue is a surface residue

is_terminus(...)
is_terminus( (Residue)arg1) -> bool : Returns true if the residue has a terminus variant

is_triazolemer(...)
is_triazolemer( (Residue)arg1) -> bool : Returns true if and only if this residue is a triazolemer

is_upper_terminus(...)
is_upper_terminus( (Residue)arg1) -> bool : Return true if the residue has an upper terminus variant

is_virtual(...)
is_virtual( (Residue)arg1, (int)atomno) -> bool : Check if atom is virtual.

is_virtual_residue(...)
is_virtual_residue( (Residue)arg1) -> bool : Check if residue is virtual.

last_backbone_atom(...)
last_backbone_atom( (Residue)arg1) -> int : Returns the index number of the last backbone heavyatom The heavyatoms come first in atom ordering, first backbone then sidechain, hydrogens follow the order of their attached heavyatom.

lower_connect(...)
lower_connect( (Residue)arg1) -> ResidueConnection : Returns this residue's lower_connection a ResidueConnection has internal coords info on how to build the atom in the previous residue which connects to this residue

lower_connect_atom(...)
lower_connect_atom( (Residue)arg1) -> int : Returns the index number of this residue's atom which connects to the residue before it in sequence : polymers only, example: for an amino acid, residue.lower_connect_atom() = atom_index("N") example(s): residue.lower_connect_atom() See also: Residue Residue.atom Residue.atoms Residue.upper_connect_atom Pose

mainchain_atom(...)
mainchain_atom( (Residue)arg1, (int)i) -> int : Returns the atom index of the residue's ith mainchain atom

mainchain_atoms(...)
mainchain_atoms( (Residue)arg1) -> vector1_Size : Returns the AtomIndices of this residue's mainchain atoms

mainchain_torsion(...)
mainchain_torsion( (Residue)arg1, (int)torsion) -> float : Returns a specific mainchain torsion angle for this residue example: mainchain_torsion(2) will be the psi angle for an amino acid example(s): residue.mainchain_torsion(2) See also: Residue Pose Pose.omega Pose.phi Pose.psi

mainchain_torsions(...)
mainchain_torsions( (Residue)arg1) -> vector1_Real : Returns the mainchain torsion angles of this residue (const) example(s): residue.mainchain_torsions() See also: Residue Pose Pose.omega Pose.phi Pose.psi

mm_atom_name(...)
mm_atom_name( (Residue)arg1, (int)atom) -> str : Returns the mm_atom_name of this residue's atom with index number <atom>

n_bonded_neighbor_all_res(...)
n_bonded_neighbor_all_res( (Residue)arg1, (int)atomno [, (bool)virt=False]) -> int : Returns the number of atoms bonded to <atomno> in all residues?

n_hbond_acceptors(...)
n_hbond_acceptors( (Residue)arg1) -> int : number of hbond_donors

n_hbond_donors(...)
n_hbond_donors( (Residue)arg1) -> int : number of hbond_donors

n_mainchain_atoms(...)
n_mainchain_atoms( (Residue)arg1) -> int : Returns the number of the residue's mainchain atoms

n_non_polymeric_residue_connections(...)
n_non_polymeric_residue_connections( (Residue)arg1) -> int : Returns the number of non-polymeric ResidueConnections on this residue

n_nus(...)
n_nus( (Residue)arg1) -> int : Return the number of nu (internal ring) angles this residue has.

n_orbitals(...)
n_orbitals( (Residue)arg1) -> int : Returns the number of orbitals in this residue

n_polymeric_residue_connections(...)
n_polymeric_residue_connections( (Residue)arg1) -> int : Returns the number of polymeric ResidueConnections on this residue

n_residue_connections(...)
n_residue_connections( (Residue)arg1) -> int : Returns the number of ResidueConnections on this residue including polymeric residue connections

n_virtual_atoms(...)
n_virtual_atoms( (Residue)arg1) -> int : Returns the number of virtual atoms in this residue.

name(...)
name( (Residue)arg1) -> str : Returns this residue's ResidueType name : for proteins, this will be the amino acid type and variant type

name1(...)
name1( (Residue)arg1) -> str : Returns this residue's 1-letter representation : for proteins, this will be the 1-letter amino acid code

name3(...)
name3( (Residue)arg1) -> str : Returns this residue's 3-letter representation : for proteins, this will be the 3-letter amino acid code

natoms(...)
natoms( (Residue)arg1) -> int : Returns the number of atoms in this residue example(s): residue.natoms() See also: Residue Pose

nbr_atom(...)
nbr_atom( (Residue)arg1) -> int : Returns the index number of this residue's atom used as a center for neighbor definition example: C-beta atom for some amino acids

nbr_atom_xyz(...)
nbr_atom_xyz( (Residue)arg1) -> xyzVector_Real : core/conformation/Residue.hh:940

nbr_radius(...)
nbr_radius( (Residue)arg1) -> float : Returns the distance cutoff value used as a radius for neighbor definition

nbrs(...)
nbrs( (Residue)arg1, (int)atm) -> vector1_Size : Convenience synonym for bonded_neighbor

nchi(...)
nchi( (Residue)arg1) -> int : Returns the number of chi angles this residue has example(s): residue.nchi() See also: Residue Pose Pose.chi Pose.set_chi

nheavyatoms(...)
nheavyatoms( (Residue)arg1) -> int : Returns the number of heavyatoms in this residue example(s): residue.nheavyatoms() See also: Residue Pose

nonconst_data_ptr(...)
nonconst_data_ptr( (Residue)arg1) -> BasicDataCache : BasicDataCache indexed by enum in residue_datacache.hh

nu(...)
nu( (Residue)arg1, (int)index) -> float : Get a specific nu (internal ring) torsion angle by index.

nu_atoms(...)
nu_atoms( (Residue)arg1) -> vec1_vec1_Size : Return the AtomIndices of each set of four atoms defining each nu angle.

nus(...)
nus( (Residue)arg1) -> vector1_Real : Return the nu (internal ring) torsion angles of this residue.

orbital_name(...)
orbital_name( (Residue)arg1, (int)orbital_index) -> str : core/conformation/Residue.hh:1016

orbital_type(...)
orbital_type( (Residue)arg1, (int)orbital_index) -> OrbitalType : core/conformation/Residue.hh:1021

orbital_type_index(...)
orbital_type_index( (Residue)arg1, (int)orbital_index) -> int : core/conformation/Residue.hh:1026

orbital_xyz(...)
orbital_xyz( (Residue)arg1, (int)orbital_index) -> xyzVector_Real : core/conformation/Residue.hh:988

orient_onto_residue(...)
orient_onto_residue( (Residue)arg1, (Residue)src) -> None : Orient our coords onto those of <src>, using the atoms from select_orient_atoms

orient_onto_residue_peptoid(...)
orient_onto_residue_peptoid( (Residue)arg1, (Residue)src, (Conformation)conformation) -> None : Orient our coords onto those of src, uses hard coded atom names (yuck) and will work for peptoid on to peptoid/peptide

path_distance(...)
path_distance( (Residue)arg1, (int)atom) -> vector1_int : Returns the shortest path distance from <atom> to any other atom in this residue example(s): See also: Residue Residue.atom Residue.atoms Pose

path_distances(...)
path_distances( (Residue)arg1) -> vec1_vec1_int : Returns the shortest path distance for any atom pair in this residue example: path_distances()[atom1][atom2] example(s): See also: Residue Residue.atom Residue.atoms Residue.path_distance Pose

place(...)
place( (Residue)arg1, (Residue)src, (Conformation)conformation [, (bool)preserve_c_beta=False]) -> None : Place this rotamer at the sequence position occupied by <src> by reorienting the ideal side chain coordinates to match

polymeric_oriented_sequence_distance(...)
polymeric_oriented_sequence_distance( (Residue)arg1, (Residue)other) -> int : Returns the sequence separation distance between this residue and <other> positive if the other residue is downstream in sequence

polymeric_sequence_distance(...)
polymeric_sequence_distance( (Residue)arg1, (Residue)other) -> int : Returns the sequence separation distance between this residue and <other> : magnitude of distance only

pseudobonds(...)
pseudobonds( (Residue)arg1) -> object : core/conformation/Residue.hh:1301

requires_actcoord(...)
requires_actcoord( (Residue)arg1) -> bool : does this residue require an actcoord?

residue_connect_atom_index(...)
residue_connect_atom_index( (Residue)arg1, (int)resconn_id) -> int : core/conformation/Residue.hh:1154

residue_connection(...)
residue_connection( (Residue)arg1, (int)resconn_index) -> ResidueConnection : Returns this residue's ResidueConnection a ResidueConnection has internal coords info on how to build the atom in a different residue which connects to this residue

residue_connection_conn_id(...)
residue_connection_conn_id( (Residue)arg1, (int)resconn_index) -> int : Returns the connection id on the OTHER residue connected to this residue at this residue's connection resconn_index.

residue_connection_partner(...)
residue_connection_partner( (Residue)arg1, (int)resconn_index) -> int : Returns the residue number of a residue connected to this residue at this residue's connection resconn_index.

residue_type_set(...)
residue_type_set( (Residue)arg1) -> ResidueTypeSet : Returns this residue's ResidueTypeSet

ring_conformer(...)
ring_conformer( (Residue)arg1) -> RingConformer : Return the current RingConformer of this residue.

select_orient_atoms(...)
select_orient_atoms( (Residue)arg1, (int)center, (int)nbr1, (int)nbr2) -> None : Selects three atoms for orienting this residue

seqpos(...)
seqpos( (Residue)arg1) -> int : Returns the sequence position of this residue

set_all_chi(...)
set_all_chi( (Residue)arg1, (vector1_Real)chis) -> None : Sets all of this residue's chi angles using the set_chi function (wrapper function)

set_chi(...)
set_chi( (Residue)arg1, (int)chino, (float)setting) -> None : Sets this residue's chi angle <chino> to <setting> assuming that changes propagate according to the atom_base tree

set_d(...)
set_d( (Residue)arg1, (int)chino, (float)setting) -> None : bondlength analog to set_chi like set_chi, assumes changes propagate to atomtree keyed off of chi#, so we only allow distances corresponding to chi angles to refine distance corresponds to the distance between atoms 3 and 4 defining the chi chino==0 ==> CA-CB distance, which allows us to refine ALA CB position for example fpd

set_orbital_xyz(...)
set_orbital_xyz( (Residue)arg1, (int)orbital_index, (xyzVector_Real)xyz_in) -> None : core/conformation/Residue.hh:994

set_pseudobonds_to_residue(...)
set_pseudobonds_to_residue( (Residue)arg1, (int)resid, (PseudoBondCollection)pbs) -> None : core/conformation/Residue.hh:1307

set_theta(...)
set_theta( (Residue)arg1, (int)chino, (float)setting) -> None : bondangle analog to set_chi same idea as set_d fpd

set_xyz(...)
set_xyz( (Residue)arg1, (int)atm_index, (xyzVector_Real)xyz_in) -> None : Sets the position of this residue's atom with index number <atm_index> example(s): See also: Residue Residue.atom Residue.atoms Residue.xyz Pose

show(...)
show( (Residue)arg1, (OStream)output [, (bool)output_atomic_details=False]) -> None : Generate string representation of Residue for debugging purposes.

sidechainAtoms_begin(...)
sidechainAtoms_begin( (Residue)arg1) -> object : should be safe, given the atom ordering rules?

type(...)
type( (Residue)arg1) -> ResidueType : Returns this residue's ResidueType example(s): residue.type() See also: Residue Residue.atom_type

update_actcoord(...)
update_actcoord( (Residue)arg1) -> None : Updates actcoord for this residue

update_connections_to_other_residue(...)
update_connections_to_other_residue( (Residue)arg1, (Residue)other_rsd) -> None : Search through the other residue for connections to this residue, and ensure that this residue's connect_map is up to date with that residue's connection indices (and residue number).

update_orbital_coords(...)
update_orbital_coords( (Residue)arg1) -> None : core/conformation/Residue.hh:1032

update_sequence_numbering(...)
update_sequence_numbering( (Residue)arg1, (vector1_Size)old2new) -> None : Updates the sequence numbers for this residue and the numbers stored about its non-polymer connections called by our owning conformation when the sequence numbers are remapped

upper_connect(...)
upper_connect( (Residue)arg1) -> ResidueConnection : Returns this residue's upper_connection a ResidueConnection has internal coords info on how to build the atom in the next residue which connects to this residue

upper_connect_atom(...)
upper_connect_atom( (Residue)arg1) -> int : Returns the index number of this residue's atom which connects to the residue after it in sequence : polymers only, example: for an amino acid, residue.upper_connect_atom() = atom_index("C") example(s): residue.upper_connect_atom() See also: Residue Residue.atom Residue.atoms Residue.lower_connect_atom Pose

xyz(...)
xyz( (Residue)arg1, (int)atm_index) -> xyzVector_Real : Returns the position of this residue's atom with index number <atm_index> : position is a Vector example(s): residue.xyz(3) See also: Residue Residue.atom Residue.atoms Residue.set_xyz Pose

Inherited from unreachable.instance: __new__

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

Class Variables

[hide private]

__instance_size__ = 32

Properties

[hide private]

Inherited from object: __class__

Method Details

[hide private]

Haro_index(...)


Haro_index( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of this residue's aromatic hydrogens
    : AtomIndices == vector1< Size >
    example(s):
        residue.Haro_index()
    See also:
        Residue
        Residue.atoms
        Residue.Hpol_index
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > Haro_index(core::conformation::Residue {lvalue})

Hpol_index(...)


Hpol_index( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of this residue's polar hydrogens
    : AtomIndices == vector1< Size >
    example(s):
        residue.Hpol_index()
    See also:
        Residue
        Residue.atoms
        Residue.Hpol_index
        Residue.Hpos_apolar
        Residue.Hpos_polar
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > Hpol_index(core::conformation::Residue {lvalue})

Hpos_apolar(...)


Hpos_apolar( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of this residue's apolar hydrogens
    : AtomIndices == vector1< Size >
    example(s):
        residue.Hpos_apolar()
    See also:
        Residue
        Residue.atoms
        Residue.Hpol_index()
        Residue.Hpos_polar
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > Hpos_apolar(core::conformation::Residue {lvalue})

Hpos_polar(...)


Hpos_polar( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of this residue's polar hydrogens
    : AtomIndices == vector1< Size >
    example(s):
        residue.Hpos_polar()
    See also:
        Residue
        Residue.atoms
        Residue.Hpol_index
        Residue.Hpos_apolar
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > Hpos_polar(core::conformation::Residue {lvalue})

Hpos_polar_sc(...)


Hpos_polar_sc( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of this residue's polar sidechain hydrogens
    : AtomIndices == vector1< Size >
    example(s):
        residue.Hpos_polar_sc()
    See also:
        Residue
        Residue.atoms
        Residue.Hpol_index
        Residue.Hpos_polar
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > Hpos_polar_sc(core::conformation::Residue {lvalue})

RNA_type(...)


RNA_type( (Residue)arg1) -> RNA_ResidueType :
    Return the RNA_residueType object. This is RNA specific.
    

    C++ signature :
        core::chemical::rna::RNA_ResidueType RNA_type(core::conformation::Residue {lvalue})

init(...)
(Constructor)


__init__( (object)arg1, (ResidueType)rsd_type_in, (bool)dummy_arg) -> None :
    constructors
    

    C++ signature :
        void __init__(_object*,core::chemical::ResidueType,bool)

__init__( (object)arg1, (ResidueType)rsd_type_in, (Residue)current_rsd, (Conformation)conformation [, (bool)preserve_c_beta=False]) -> None :
    Rotamer-style constructor; orients ideal coords onto backbone of current_rsd
    

    C++ signature :
        void __init__(_object*,core::chemical::ResidueType,core::conformation::Residue,core::conformation::Conformation [,bool=False])

__init__( (object)arg1, (Residue)src) -> None :
    core/conformation/Residue.hh:107

    C++ signature :
        void __init__(_object*,core::conformation::Residue)

Overrides: object.__init__

reduce(...)

helper for pickle

Overrides: object.__reduce__: (inherited documentation)

str(...)
(Informal representation operator)


__str__( (Residue)arg1) -> object :

    C++ signature :
        _object* __str__(core::conformation::Residue {lvalue})

Overrides: object.__str__

aa(...)


aa( (Residue)arg1) -> AA :
    Returns this residue's AA type, if any
    Used for knowledge-based scores, dunbrack, etc. could be "aa_unk"
    AA is enumeration
    

    C++ signature :
        core::chemical::AA aa(core::conformation::Residue {lvalue})

abase2(...)


abase2( (Residue)arg1, (int)atomno) -> int :
    Returns the atom index of the  <atomno>  atom's second base atom
    note: abase2 is this atom's first bonded neighbor other than
    this atom's base atom (unless it has only one neighbor)
    

    C++ signature :
        unsigned long abase2(core::conformation::Residue {lvalue},int)

accpt_pos(...)


accpt_pos( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of this residue's h-bond acceptor atoms
    : AtomIndices == vector1< Size >
    example(s):
        residue.accpt_pos()
    See also:
        Residue
        Residue.accpt_pos_sc
        Residue.atoms
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > accpt_pos(core::conformation::Residue {lvalue})

accpt_pos_sc(...)


accpt_pos_sc( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of this residue's sidechain h-bond acceptor atoms
    : AtomIndices == vector1< Size >
    example(s):
        residue.accpt_pos_sc()
    See also:
        Residue
        Residue.accpt_pos
        Residue.atoms
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > accpt_pos_sc(core::conformation::Residue {lvalue})

actcoord(...)


actcoord( (Residue)arg1) -> xyzVector_Real :
    Returns the coordinates used for pairE calculations (amino acids only)
    

    C++ signature :
        numeric::xyzVector<double> actcoord(core::conformation::Residue {lvalue})

actcoord( (Residue)arg1) -> xyzVector_Real :
    Returns the coordinates used for pairE calculations (amino acids only)
    

    C++ signature :
        numeric::xyzVector<double> {lvalue} actcoord(core::conformation::Residue {lvalue})

actcoord_atoms(...)


actcoord_atoms( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of atoms that will be used to define this residue's actcoord.
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > actcoord_atoms(core::conformation::Residue {lvalue})

actual_residue_connection(...)


actual_residue_connection( (Residue)arg1, (int)resconnid) -> ResConnID :
    core/conformation/Residue.hh:1200

    C++ signature :
        core::chemical::ResConnID actual_residue_connection(core::conformation::Residue {lvalue},unsigned long)

all_bb_atoms(...)


all_bb_atoms( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of this residue's backbone atoms
    : heavyatoms and hydrogens, AtomIndices == vector1< Size >
    example(s):
        residue.all_bb_atoms()
    See also:
        Residue
        Residue.atoms
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > all_bb_atoms(core::conformation::Residue {lvalue})

apply_transform_Rx_plus_v(...)


apply_transform_Rx_plus_v( (Residue)arg1, (xyzMatrix_Real)R, (xyzVector_Real)v) -> None :
    Applies a transform of the form Rx + v, where R is a rotation
    matrix, V is a vector, and x is the original position in xyz space
    

    C++ signature :
        void apply_transform_Rx_plus_v(core::conformation::Residue {lvalue},numeric::xyzMatrix<double>,numeric::xyzVector<double>)

atom(...)


atom( (Residue)arg1, (int)atm_index) -> Atom :
    Returns this residue's Atom with index number  <atm_index>  (const)
    : Atom object is xyz and atom_type
    example(s):
        residue.atom(3)
    See also:
        Residue
        Residue.atoms
        Pose
    

    C++ signature :
        core::conformation::Atom atom(core::conformation::Residue {lvalue},unsigned long)

atom( (Residue)arg1, (int)atm_index) -> Atom :
    Returns this residue's Atom with index number  <atm_index>  (non-const)
    : Atom object is xyz and atom_type
    example(s):
        residue.atom(3)
    See also:
        Residue
        Residue.atoms
        Pose
    

    C++ signature :
        core::conformation::Atom {lvalue} atom(core::conformation::Residue {lvalue},unsigned long)

atom( (Residue)arg1, (str)atm_name) -> Atom :
    Returns this residue's Atom with name  <atm_name>  (const)
    : Atom object is xyz and atom_type, slower but safer than hard-coding an integer index in code where you
    need a specific atom
    example(s):
        residue.atom(3)
    See also:
        Residue
        Residue.atoms
        Pose
    

    C++ signature :
        core::conformation::Atom atom(core::conformation::Residue {lvalue},std::string)

atom( (Residue)arg1, (str)atm_name) -> Atom :
    Returns this residue's Atom with name  <atm_name>  (non-const)
    : Atom object is xyz and atom_type, slower but safer than hard-coding an integer index in code where you
    need a specific atom
    example(s):
        residue.atom(3)
    See also:
        Residue
        Residue.atoms
        Pose
    

    C++ signature :
        core::conformation::Atom {lvalue} atom(core::conformation::Residue {lvalue},std::string)

atom_base(...)


atom_base( (Residue)arg1, (int)atomno) -> int :
    Returns the atom index of the  <atomno>  atom's base atom
    

    C++ signature :
        unsigned long atom_base(core::conformation::Residue {lvalue},int)

atom_begin(...)


atom_begin( (Residue)arg1) -> object :
    begin interator, to iterate over atoms
    

    C++ signature :
        __gnu_cxx::__normal_iterator<core::conformation::Atom*, std::vector<core::conformation::Atom, std::allocator<core::conformation::Atom> > > atom_begin(core::conformation::Residue {lvalue})

atom_begin( (Residue)arg1) -> object :
    core/conformation/Residue.hh:457

    C++ signature :
        __gnu_cxx::__normal_iterator<core::conformation::Atom const*, std::vector<core::conformation::Atom, std::allocator<core::conformation::Atom> > > atom_begin(core::conformation::Residue {lvalue})

atom_end(...)


atom_end( (Residue)arg1) -> object :
    end interator, to iterate over atoms
    

    C++ signature :
        __gnu_cxx::__normal_iterator<core::conformation::Atom*, std::vector<core::conformation::Atom, std::allocator<core::conformation::Atom> > > atom_end(core::conformation::Residue {lvalue})

atom_end( (Residue)arg1) -> object :
    core/conformation/Residue.hh:458

    C++ signature :
        __gnu_cxx::__normal_iterator<core::conformation::Atom const*, std::vector<core::conformation::Atom, std::allocator<core::conformation::Atom> > > atom_end(core::conformation::Residue {lvalue})

atom_index(...)


atom_index( (Residue)arg1, (str)atm) -> int :
    Returns the index number of the  <atm>  in this residue
    example: residue.atom_index("CA") returns 2 for a normal amino acid
    example(s):
        residue.atom_index("CA")
    See also:
        Residue
        AtomType
        Pose
    

    C++ signature :
        unsigned long atom_index(core::conformation::Residue {lvalue},std::string)

atom_is_backbone(...)


atom_is_backbone( (Residue)arg1, (int)atomno) -> bool :
    Returns true if this residue's atom with index number  <atomno>  is a backbone atom
    example(s):
        residue.atom_is_backbone(3)
    See also:
        Residue
        Residue.all_bb_atoms
        Residue.atom
        Residue.atoms
        Pose
    

    C++ signature :
        bool atom_is_backbone(core::conformation::Residue {lvalue},int)

atom_is_hydrogen(...)


atom_is_hydrogen( (Residue)arg1, (int)atomno) -> bool :
    Returns true if this residue's atom with index number  <atomno>  is a hydrogen
    example(s):
        residue.atom_is_backbone(3)
    See also:
        Residue
        Residue.all_bb_atoms
        Residue.atom
        Residue.atoms
        Pose
    

    C++ signature :
        bool atom_is_hydrogen(core::conformation::Residue {lvalue},unsigned long)

atom_is_polar_hydrogen(...)


atom_is_polar_hydrogen( (Residue)arg1, (int)ind) -> bool :
    Is a particular atom a polar hydrogen?
    

    C++ signature :
        bool atom_is_polar_hydrogen(core::conformation::Residue {lvalue},unsigned long)

atom_name(...)


atom_name( (Residue)arg1, (int)atm) -> str :
    //////////////////////////
     Returns the name of this residue's atom with index number  <atm>
    

    C++ signature :
        std::string atom_name(core::conformation::Residue {lvalue},int)

atom_type(...)


atom_type( (Residue)arg1, (int)atomno) -> AtomType :
    ///////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////
    ////////////// Atom Functions              ////////////////////////
    ///////////////Atom Functions             /////////////////////////
    ///////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////
     Returns the AtomType of this residue's atom with index number  <atomno>
    
     example(s):
         residue.atom_type(3)
     See also:
         Residue
         Residue.atom_index
         AtomType
         Pose
    

    C++ signature :
        core::chemical::AtomType atom_type(core::conformation::Residue {lvalue},int)

atom_type_index(...)


atom_type_index( (Residue)arg1, (int)atomno) -> int :
    Returns the atom_type_index of this residue's atom with index number  <atomno>
    atom_type_index is used to query this atom's AtomType from an AtomTypeSet,
    example: AtomTypeSet[atom_type_index] = AtomType
    example(s):
        residue.atom_type_index(3)
    See also:
        Residue
        Residue.atom_index
        AtomType
        Pose
    

    C++ signature :
        unsigned long atom_type_index(core::conformation::Residue {lvalue},unsigned long)

atom_type_set(...)


atom_type_set( (Residue)arg1) -> AtomTypeSet :
    Returns the AtomTypeSet of this residue
    example(s):
        residue.atom_type_set()
    See also:
        Residue
        Residue.atom_type_index
        AtomType
        Pose
    

    C++ signature :
        core::chemical::AtomTypeSet atom_type_set(core::conformation::Residue {lvalue})

atomic_charge(...)


atomic_charge( (Residue)arg1, (int)atomno) -> float :
    Returns the atom charge of this residue's atom with index number  <atomno>
    example(s):
        residue.atomic_charge(3)
    See also:
        Residue
        Residue.atom_index
        Pose
    

    C++ signature :
        double atomic_charge(core::conformation::Residue {lvalue},int)

atoms(...)


atoms( (Residue)arg1) -> vector1_core_conformation_Atom :
    Returns this residue's Atoms (const), a vector1 of Atom objects
    example(s):
        residue.atoms()
    See also:
        Residue
        Pose
    

    C++ signature :
        utility::vector1<core::conformation::Atom, std::allocator<core::conformation::Atom> > atoms(core::conformation::Residue {lvalue})

atoms( (Residue)arg1) -> vector1_core_conformation_Atom :
    Returns this residue's Atoms (non-const), a vector1 of Atom objects
    example(s):
        residue.atoms()
    See also:
        Residue
        Pose
    

    C++ signature :
        utility::vector1<core::conformation::Atom, std::allocator<core::conformation::Atom> > {lvalue} atoms(core::conformation::Residue {lvalue})

atoms_with_orb_index(...)


atoms_with_orb_index( (Residue)arg1) -> vector1_Size :
    ///////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////
    //////////////         Orbital Functions     //////////////////////
    /////////////          Orbital Functions     //////////////////////
    ///////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////
     

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > atoms_with_orb_index(core::conformation::Residue {lvalue})

attached_H_begin(...)


attached_H_begin( (Residue)arg1, (int)atom) -> int :
    Returns the index number of the first hydrogen attached to the atom
    with index number  <atom>
    example(s):
        residue.attached_H_begin()
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.attached_H_end
        Pose
    

    C++ signature :
        unsigned long attached_H_begin(core::conformation::Residue {lvalue},int)

attached_H_begin( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of the first hydrogen attached to each heavyatom
    example(s):
        residue.attached_H_begin()
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.attached_H_end
        Residue.nheavyatoms
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > attached_H_begin(core::conformation::Residue {lvalue})

attached_H_end(...)


attached_H_end( (Residue)arg1, (int)atom) -> int :
    Returns the index number of the last hydrogen attached to the atom
    with index number  <atom>
    example(s):
        residue.attached_H_end()
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.attached_H_begin
        Pose
    

    C++ signature :
        unsigned long attached_H_end(core::conformation::Residue {lvalue},int)

attached_H_end( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of the last hydrogen attached to each heavyatom
    example(s):
        residue.attached_H_end()
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.attached_H_begin
        Residue.nheavyatoms
        Pose
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > attached_H_end(core::conformation::Residue {lvalue})

backbone_aa(...)


backbone_aa( (Residue)arg1) -> AA :
    Returns this residue's backbone_aa type, if any.
    This is used for noncanonical alpha-amino acids that are templated on canonicals.
    For example, 4,5-dihydroxyisoleucine uses the ramachandran and p_aa_pp scoring of isoleucine.
    

    C++ signature :
        core::chemical::AA backbone_aa(core::conformation::Residue {lvalue})

bonded_neighbor(...)


bonded_neighbor( (Residue)arg1, (int)atm) -> vector1_Size :
    Returns the AtomIndices for all bonded neighbor atoms of  <atm>
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > bonded_neighbor(core::conformation::Residue {lvalue},int)

bonded_orbitals(...)


bonded_orbitals( (Residue)arg1, (int)atm) -> vector1_Size :
    core/conformation/Residue.hh:1010

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > bonded_orbitals(core::conformation::Residue {lvalue},int)

build_atom_ideal(...)


build_atom_ideal( (Residue)arg1, (int)atomno, (Conformation)conformation) -> xyzVector_Real :
    Return coordinates for building an atom from ideal internal coordinates,
    used for building missing atoms
    

    C++ signature :
        numeric::xyzVector<double> build_atom_ideal(core::conformation::Residue {lvalue},int,core::conformation::Conformation)

build_orbital_xyz(...)


build_orbital_xyz( (Residue)arg1, (int)orbital_index) -> xyzVector_Real :
    core/conformation/Residue.hh:966

    C++ signature :
        numeric::xyzVector<double> build_orbital_xyz(core::conformation::Residue {lvalue},unsigned long)

carbohydrate_info(...)


carbohydrate_info( (Residue)arg1) -> CarbohydrateInfo :
    Return the CarbohydrateInfo object containing sugar-specific properties for this residue.
    

    C++ signature :
        boost::shared_ptr<core::chemical::carbohydrates::CarbohydrateInfo const> carbohydrate_info(core::conformation::Residue {lvalue})

chain(...)


chain( (Residue)arg1) -> int :
    Returns this residue's chain id
    

    C++ signature :
        unsigned long chain(core::conformation::Residue {lvalue})

chain( (Residue)arg1, (int)setting) -> None :
    Sets this residue's chain id
    

    C++ signature :
        void chain(core::conformation::Residue {lvalue},int)

chi(...)


chi( (Residue)arg1) -> vector1_Real :
    Returns the chi torsion angles of this residue (const)
    example(s):
        residue.chi()
    See also:
        Residue
        Residue.nchi
        Pose
        Pose.chi
    

    C++ signature :
        utility::vector1<double, std::allocator<double> > chi(core::conformation::Residue {lvalue})

chi( (Residue)arg1) -> vector1_Real :
    Returns the chi torsion angles of this residue (non-const)
    

    C++ signature :
        utility::vector1<double, std::allocator<double> > {lvalue} chi(core::conformation::Residue {lvalue})

chi( (Residue)arg1, (vector1_Real)chis) -> None :
    Sets the chi torsion angles of this residue
    CAUTION: This function does not cause updating to any internal coordinate data.
    See Residue::set_chi() and Residue::set_all_chi() functions for
    versions which handle coordinate updates.
    example(s):
    See also:
        Residue
        Pose
        Pose.set_chi
    

    C++ signature :
        void chi(core::conformation::Residue {lvalue},utility::vector1<double, std::allocator<double> >)

chi( (Residue)arg1, (int)chino) -> float :
    get a specific chi torsion angle
    example(s):
        residue.chi(1)
    See also:
        Residue
        Pose
        Pose.chi
    

    C++ signature :
        double chi(core::conformation::Residue {lvalue},unsigned long)

chi_atoms(...)


chi_atoms( (Residue)arg1) -> vec1_vec1_Size :
    Returns the AtomIndices of each set of four atoms defining each chi angle
    

    C++ signature :
        utility::vector1<utility::vector1<unsigned long, std::allocator<unsigned long> >, std::allocator<utility::vector1<unsigned long, std::allocator<unsigned long> > > > chi_atoms(core::conformation::Residue {lvalue})

chi_atoms( (Residue)arg1, (int)chino) -> vector1_Size :
    Returns the AtomIndices of the four atoms defining this residue's  <chino>  chi angle
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > chi_atoms(core::conformation::Residue {lvalue},int)

chi_rotamers(...)


chi_rotamers( (Residue)arg1, (int)chino) -> vector1_pair_Real_Real :
    Returns the chi rotamers available for this residue's chi angle  <chino>
    

    C++ signature :
        utility::vector1<std::pair<double, double>, std::allocator<std::pair<double, double> > > chi_rotamers(core::conformation::Residue {lvalue},unsigned long)

clear_residue_connections(...)


clear_residue_connections( (Residue)arg1) -> None :
    core/conformation/Residue.hh:1175

    C++ signature :
        void clear_residue_connections(core::conformation::Residue {lvalue})

clone(...)


clone( (Residue)arg1) -> Residue :
    Copy this residue( allocate actual memory for it )
    

    C++ signature :
        boost::shared_ptr<core::conformation::Residue> clone(core::conformation::Residue {lvalue})

connect_atom(...)


connect_atom( (Residue)arg1, (Residue)other) -> int :
    Returns the index number of this residue's atom connected to the  <other>  Residue
    example(s):
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.lower_connect_atom
        Residue.upper_connect_atom
        Pose
    

    C++ signature :
        unsigned long connect_atom(core::conformation::Residue {lvalue},core::conformation::Residue)

connect_map(...)


connect_map( (Residue)arg1, (int)resconn_index) -> ResConnID :
    core/conformation/Residue.hh:1165

    C++ signature :
        core::chemical::ResConnID connect_map(core::conformation::Residue {lvalue},unsigned long)

connect_map_size(...)


connect_map_size( (Residue)arg1) -> int :
    Returns the size (number of elements) in the connect_map_ object.
    

    C++ signature :
        unsigned long connect_map_size(core::conformation::Residue {lvalue})

connected_residue_at_resconn(...)


connected_residue_at_resconn( (Residue)arg1, (int)resconn_index) -> int :
    core/conformation/Residue.hh:1160

    C++ signature :
        unsigned long connected_residue_at_resconn(core::conformation::Residue {lvalue},unsigned long)

connection_distance(...)


connection_distance( (Residue)arg1, (Conformation)conf, (int)resconn_index, (xyzVector_Real)matchpoint) -> float :
    Distance between a potential residue connection match and the position of the expected atom
    

    C++ signature :
        double connection_distance(core::conformation::Residue {lvalue},core::conformation::Conformation,unsigned long,numeric::xyzVector<double>)

connection_incomplete(...)


connection_incomplete( (Residue)arg1, (int)resconnid) -> bool :
    core/conformation/Residue.hh:1197

    C++ signature :
        bool connection_incomplete(core::conformation::Residue {lvalue},unsigned long)

connections_match(...)


connections_match( (Residue)arg1, (Residue)other) -> bool :
    Returns true if ???
    

    C++ signature :
        bool connections_match(core::conformation::Residue {lvalue},core::conformation::Residue)

connections_to_residue(...)


connections_to_residue( (Residue)arg1, (Residue)other) -> vector1_Size :
    Returns the vector1 of resconn ids that connect this residue to other
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > connections_to_residue(core::conformation::Residue {lvalue},core::conformation::Residue)

connections_to_residue( (Residue)arg1, (int)other_resid) -> vector1_Size :
    Returns the vector1 of resconn ids that connect this residue to other
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > connections_to_residue(core::conformation::Residue {lvalue},unsigned long)

copy_residue_connections(...)


copy_residue_connections( (Residue)arg1, (Residue)src_rsd) -> None :
    attempt to take residue connection info from src_rsd
    

    C++ signature :
        void copy_residue_connections(core::conformation::Residue {lvalue},core::conformation::Residue)

copy_residue_connections_from(...)


copy_residue_connections_from( (Residue)arg1, (Residue)src) -> None :
    core/conformation/Residue.hh:1185

    C++ signature :
        void copy_residue_connections_from(core::conformation::Residue {lvalue},core::conformation::Residue)

create_residue(...)


create_residue( (Residue)arg1) -> Residue :
    Returns a ResidueOP for creating a copy of residue, same as clone()
    Temporary hack until Residue hierarchy is worked out
    

    C++ signature :
        boost::shared_ptr<core::conformation::Residue> create_residue(core::conformation::Residue {lvalue})

create_rotamer(...)


create_rotamer( (Residue)arg1) -> Residue :
    ///////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////
    //////////////         Residue Functions     //////////////////////
    /////////////          Residue Functions     //////////////////////
    ///////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////
     Returns a ResidueOP for creating a rotamer of this residue
     Temporary hack until Residue hierarchy is worked out
    

    C++ signature :
        boost::shared_ptr<core::conformation::Residue> create_rotamer(core::conformation::Residue {lvalue})

cut_bond_neighbor(...)


cut_bond_neighbor( (Residue)arg1, (int)atm) -> vector1_Size :
    atom indices for bonded neighbors to which atom-tree connections are disallowed.
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > cut_bond_neighbor(core::conformation::Residue {lvalue},int)

data_ptr(...)


data_ptr( (Residue)arg1) -> BasicDataCache :
    BasicDataCache indexed by enum in residue_datacache.hh
    

    C++ signature :
        boost::shared_ptr<basic::datacache::BasicDataCache const> data_ptr(core::conformation::Residue {lvalue})

fill_missing_atoms(...)


fill_missing_atoms( (Residue)arg1, (vector1_bool)missing, (Conformation)conformation) -> None :
    Builds coordinates for atoms missing from this residue
    assuming ideal internal coordinates
    

    C++ signature :
        void fill_missing_atoms(core::conformation::Residue {lvalue},utility::vector1<bool, std::allocator<bool> >,core::conformation::Conformation)

first_sidechain_atom(...)


first_sidechain_atom( (Residue)arg1) -> int :
    Returns the index number of the first sidechain heavyatom
    example(s):
        residue.first_sidechain_atom()
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.last_backbone_atom
        Pose
    

    C++ signature :
        unsigned long first_sidechain_atom(core::conformation::Residue {lvalue})

first_sidechain_hydrogen(...)


first_sidechain_hydrogen( (Residue)arg1) -> int :
    Returns the index number of the first sidechain hydrogen
    example(s):
        residue.first_sidechain_hydrogen()
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.first_sidechain_atom
        Pose
    

    C++ signature :
        unsigned long first_sidechain_hydrogen(core::conformation::Residue {lvalue})

get_metal_binding_atoms(...)


get_metal_binding_atoms( (Residue)arg1, (vector1_Size)metal_binding_indices) -> None :
    Gets the AtomIndices of the atoms in this residue that can bind to metals
    : AtomIndices == vector1< Size >
    : Vikram K. Mulligan (vmullig@uw.edu)
    

    C++ signature :
        void get_metal_binding_atoms(core::conformation::Residue {lvalue},utility::vector1<unsigned long, std::allocator<unsigned long> > {lvalue})

get_pseudobonds_to_residue(...)


get_pseudobonds_to_residue( (Residue)arg1, (int)resid) -> PseudoBondCollection :
    core/conformation/Residue.hh:1298

    C++ signature :
        boost::shared_ptr<core::conformation::PseudoBondCollection const> get_pseudobonds_to_residue(core::conformation::Residue {lvalue},unsigned long)

get_self_ptr(...)


get_self_ptr( (Residue)arg1) -> Residue :
    self pointers
    

    C++ signature :
        boost::shared_ptr<core::conformation::Residue const> get_self_ptr(core::conformation::Residue {lvalue})

get_self_ptr( (Residue)arg1) -> Residue :
    core/conformation/Residue.hh:119

    C++ signature :
        boost::shared_ptr<core::conformation::Residue> get_self_ptr(core::conformation::Residue {lvalue})

get_self_weak_ptr(...)


get_self_weak_ptr( (Residue)arg1) -> ResidueCAP :
    core/conformation/Residue.hh:120

    C++ signature :
        boost::weak_ptr<core::conformation::Residue const> get_self_weak_ptr(core::conformation::Residue {lvalue})

get_self_weak_ptr( (Residue)arg1) -> ResidueAP :
    core/conformation/Residue.hh:121

    C++ signature :
        boost::weak_ptr<core::conformation::Residue> get_self_weak_ptr(core::conformation::Residue {lvalue})

has(...)


has( (Residue)arg1, (str)atm) -> bool :
    Returns true if this residue has an atom named  <atm>
    

    C++ signature :
        bool has(core::conformation::Residue {lvalue},std::string)

has_incomplete_connection(...)


has_incomplete_connection( (Residue)arg1) -> bool :
    core/conformation/Residue.hh:1188

    C++ signature :
        bool has_incomplete_connection(core::conformation::Residue {lvalue})

has_incomplete_connection( (Residue)arg1, (int)atomno) -> bool :
    Returns true is  <atomno>  has complete connectivity?
    

    C++ signature :
        bool has_incomplete_connection(core::conformation::Residue {lvalue},unsigned long)

has_lower_connect(...)


has_lower_connect( (Residue)arg1) -> int :
    Returns true if residue has a valid lower connection.
    example(s):
        residue.has_lower_connect()
    

    C++ signature :
        unsigned long has_lower_connect(core::conformation::Residue {lvalue})

has_property(...)


has_property( (Residue)arg1, (str)property) -> bool :
    Return true if the residue has <property>.
    

    C++ signature :
        bool has_property(core::conformation::Residue {lvalue},std::string)

has_sc_orbitals(...)


has_sc_orbitals( (Residue)arg1) -> bool :
    Returns true if the residue has side chain orbitals
    

    C++ signature :
        bool has_sc_orbitals(core::conformation::Residue {lvalue})

has_upper_connect(...)


has_upper_connect( (Residue)arg1) -> int :
    Returns true if residue has a valid upper connection.
    example(s):
        residue.has_upper_connect()
    

    C++ signature :
        unsigned long has_upper_connect(core::conformation::Residue {lvalue})

has_variant_type(...)


has_variant_type( (Residue)arg1, (VariantType)variant_type) -> bool :
    Generic variant access
    

    C++ signature :
        bool has_variant_type(core::conformation::Residue {lvalue},core::chemical::VariantType)

heavyAtoms_end(...)


heavyAtoms_end( (Residue)arg1) -> object :
    core/conformation/Residue.hh:465

    C++ signature :
        __gnu_cxx::__normal_iterator<core::conformation::Atom const*, std::vector<core::conformation::Atom, std::allocator<core::conformation::Atom> > > heavyAtoms_end(core::conformation::Residue {lvalue})

heavyatom_has_polar_hydrogens(...)


heavyatom_has_polar_hydrogens( (Residue)arg1, (int)ind) -> bool :
    Is a particular atom a heavy atom with chemically bound polar hydrogens? (i.e. a donor heavy atom)
    

    C++ signature :
        bool heavyatom_has_polar_hydrogens(core::conformation::Residue {lvalue},unsigned long)

heavyatom_is_an_acceptor(...)


heavyatom_is_an_acceptor( (Residue)arg1, (int)ind) -> bool :
    Is a particular atom a heavy atom acceptor?
    

    C++ signature :
        bool heavyatom_is_an_acceptor(core::conformation::Residue {lvalue},unsigned long)

icoor(...)


icoor( (Residue)arg1, (int)atm) -> AtomICoor :
    Returns the internal coordinates of this residue's atom with index number  <atm>
    

    C++ signature :
        core::chemical::AtomICoor icoor(core::conformation::Residue {lvalue},int)

is_DNA(...)


is_DNA( (Residue)arg1) -> bool :
    Returns true if this residue is a DNA residue
    

    C++ signature :
        bool is_DNA(core::conformation::Residue {lvalue})

is_NA(...)


is_NA( (Residue)arg1) -> bool :
    Returns true if this residue is a nucleic acid
    

    C++ signature :
        bool is_NA(core::conformation::Residue {lvalue})

is_RNA(...)


is_RNA( (Residue)arg1) -> bool :
    Returns true if this residue is a RNA residue
    

    C++ signature :
        bool is_RNA(core::conformation::Residue {lvalue})

is_apolar(...)


is_apolar( (Residue)arg1) -> bool :
    Returns true if the residue is apolar
    : apolar is classified as NOT polar, aromatic, or charged
    

    C++ signature :
        bool is_apolar(core::conformation::Residue {lvalue})

is_aromatic(...)


is_aromatic( (Residue)arg1) -> bool :
    Returns true if the residue is aromatic
    

    C++ signature :
        bool is_aromatic(core::conformation::Residue {lvalue})

is_bonded(...)


is_bonded( (Residue)arg1, (Residue)other) -> bool :
    Am I bonded to other?
    Meaningful for arbitrary topologies (e.g. circular peptides, disulfides)
    

    C++ signature :
        bool is_bonded(core::conformation::Residue {lvalue},core::conformation::Residue)

is_bonded( (Residue)arg1, (int)other_index) -> bool :
    Am I bonded to other?
    Looks at all residue connections as opposed to doing arithmetic
    

    C++ signature :
        bool is_bonded(core::conformation::Residue {lvalue},unsigned long)

is_branch_lower_terminus(...)


is_branch_lower_terminus( (Residue)arg1) -> bool :
    Return true if the residue is a branch lower terminus variant.
    

    C++ signature :
        bool is_branch_lower_terminus(core::conformation::Residue {lvalue})

is_branch_point(...)


is_branch_point( (Residue)arg1) -> bool :
    Return true if the residue is a branch point variant.
    

    C++ signature :
        bool is_branch_point(core::conformation::Residue {lvalue})

is_carbohydrate(...)


is_carbohydrate( (Residue)arg1) -> bool :
    Returns true if this residue is a carbohydrate
    

    C++ signature :
        bool is_carbohydrate(core::conformation::Residue {lvalue})

is_charged(...)


is_charged( (Residue)arg1) -> bool :
    Returns true if the residue is charged
    

    C++ signature :
        bool is_charged(core::conformation::Residue {lvalue})

is_coarse(...)


is_coarse( (Residue)arg1) -> bool :
    residue is coarse (used for RNA right now)
    

    C++ signature :
        bool is_coarse(core::conformation::Residue {lvalue})

is_ligand(...)


is_ligand( (Residue)arg1) -> bool :
    Returns true if this residue is a ligand
    

    C++ signature :
        bool is_ligand(core::conformation::Residue {lvalue})

is_lower_terminus(...)


is_lower_terminus( (Residue)arg1) -> bool :
    Returns true if the residue has a lower terminus variant
    

    C++ signature :
        bool is_lower_terminus(core::conformation::Residue {lvalue})

is_metal(...)


is_metal( (Residue)arg1) -> bool :
    Returns true if this residue is a metal ion, false otherwise.  The METAL property is specified in the params file under PROPERTIES.
    Vikram K. Mulligan (vmullig@uw.edu)
    

    C++ signature :
        bool is_metal(core::conformation::Residue {lvalue})

is_metalbinding(...)


is_metalbinding( (Residue)arg1) -> bool :
    Returns true if this residue is a type capable of binding to a metal ion (e.g. His, Cys, etc.), false otherwise.  The METALBINDING property is specified in the params file under PROPERTIES.
    Vikram K. Mulligan (vmullig@uw.edu)
    

    C++ signature :
        bool is_metalbinding(core::conformation::Residue {lvalue})

is_peptoid(...)


is_peptoid( (Residue)arg1) -> bool :
    Returns if this residue is a peptoid
    

    C++ signature :
        bool is_peptoid(core::conformation::Residue {lvalue})

is_polar(...)


is_polar( (Residue)arg1) -> bool :
    Returns true if the residue is polar
    

    C++ signature :
        bool is_polar(core::conformation::Residue {lvalue})

is_polymer(...)


is_polymer( (Residue)arg1) -> bool :
    //////////
     Returns true if this residue is a polymer
    

    C++ signature :
        bool is_polymer(core::conformation::Residue {lvalue})

is_polymer_bonded(...)


is_polymer_bonded( (Residue)arg1, (Residue)other) -> bool :
    Am I polymer bonded to other?
    

    C++ signature :
        bool is_polymer_bonded(core::conformation::Residue {lvalue},core::conformation::Residue)

is_polymer_bonded( (Residue)arg1, (int)other_index) -> bool :
    Am I polymer-bonded to other? checks lower and upper connections
    

    C++ signature :
        bool is_polymer_bonded(core::conformation::Residue {lvalue},unsigned long)

is_protein(...)


is_protein( (Residue)arg1) -> bool :
    Returns true if this residue is an amino acid
    

    C++ signature :
        bool is_protein(core::conformation::Residue {lvalue})

is_pseudo_bonded(...)


is_pseudo_bonded( (Residue)arg1, (Residue)other) -> bool :
    Do I have any pseudobonds to other?
    

    C++ signature :
        bool is_pseudo_bonded(core::conformation::Residue {lvalue},core::conformation::Residue)

is_pseudo_bonded( (Residue)arg1, (int)other_index) -> bool :
    Do I have any pseudobonds to other?
    

    C++ signature :
        bool is_pseudo_bonded(core::conformation::Residue {lvalue},unsigned long)

is_similar_aa(...)


is_similar_aa( (Residue)arg1, (Residue)other) -> bool :
    Returns true if the aa residue types are the same
    

    C++ signature :
        bool is_similar_aa(core::conformation::Residue {lvalue},core::conformation::Residue)

is_similar_rotamer(...)


is_similar_rotamer( (Residue)arg1, (Residue)other) -> bool :
    Returns true if the chi angles of another residue all fall within 5 deg
    

    C++ signature :
        bool is_similar_rotamer(core::conformation::Residue {lvalue},core::conformation::Residue)

is_sri(...)


is_sri( (Residue)arg1) -> bool :
    Is this one of SRI's special heteropolymer building blocks?
    

    C++ signature :
        bool is_sri(core::conformation::Residue {lvalue})

is_surface(...)


is_surface( (Residue)arg1) -> bool :
    Returns true if this residue is a surface residue
    

    C++ signature :
        bool is_surface(core::conformation::Residue {lvalue})

is_terminus(...)


is_terminus( (Residue)arg1) -> bool :
    Returns true if the residue has a terminus variant
    

    C++ signature :
        bool is_terminus(core::conformation::Residue {lvalue})

is_triazolemer(...)


is_triazolemer( (Residue)arg1) -> bool :
    Returns true if and only if this residue is a triazolemer
    

    C++ signature :
        bool is_triazolemer(core::conformation::Residue {lvalue})

is_upper_terminus(...)


is_upper_terminus( (Residue)arg1) -> bool :
    Return true if the residue has an upper terminus variant
    

    C++ signature :
        bool is_upper_terminus(core::conformation::Residue {lvalue})

is_virtual(...)


is_virtual( (Residue)arg1, (int)atomno) -> bool :
    Check if atom is virtual.
    

    C++ signature :
        bool is_virtual(core::conformation::Residue {lvalue},unsigned long)

is_virtual_residue(...)


is_virtual_residue( (Residue)arg1) -> bool :
    Check if residue is virtual.
    

    C++ signature :
        bool is_virtual_residue(core::conformation::Residue {lvalue})

last_backbone_atom(...)


last_backbone_atom( (Residue)arg1) -> int :
    Returns the index number of the last backbone heavyatom
    The heavyatoms come first in atom ordering,
    first backbone then sidechain, hydrogens follow the order
    of their attached heavyatom.
    example(s):
        residue.last_backbone_atom()
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.first_sidechain_atom
        Pose
    

    C++ signature :
        unsigned long last_backbone_atom(core::conformation::Residue {lvalue})

lower_connect(...)


lower_connect( (Residue)arg1) -> ResidueConnection :
    Returns this residue's lower_connection
    a ResidueConnection has internal coords info
    on how to build the atom in the previous residue which
    connects to this residue
    

    C++ signature :
        core::chemical::ResidueConnection lower_connect(core::conformation::Residue {lvalue})

lower_connect_atom(...)


lower_connect_atom( (Residue)arg1) -> int :
    Returns the index number of this residue's atom which connects to
    the residue before it in sequence
    : polymers only, example: for an amino acid, residue.lower_connect_atom() = atom_index("N")
    example(s):
        residue.lower_connect_atom()
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.upper_connect_atom
        Pose
    

    C++ signature :
        unsigned long lower_connect_atom(core::conformation::Residue {lvalue})

mainchain_atom(...)


mainchain_atom( (Residue)arg1, (int)i) -> int :
    Returns the atom index of the residue's ith mainchain atom
    

    C++ signature :
        unsigned long mainchain_atom(core::conformation::Residue {lvalue},unsigned long)

mainchain_atoms(...)


mainchain_atoms( (Residue)arg1) -> vector1_Size :
    Returns the AtomIndices of this residue's mainchain atoms
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > mainchain_atoms(core::conformation::Residue {lvalue})

mainchain_torsion(...)


mainchain_torsion( (Residue)arg1, (int)torsion) -> float :
    Returns a specific mainchain torsion angle for this residue
    example: mainchain_torsion(2) will be the psi angle for an amino acid
    example(s):
        residue.mainchain_torsion(2)
    See also:
        Residue
        Pose
        Pose.omega
        Pose.phi
        Pose.psi
    

    C++ signature :
        double mainchain_torsion(core::conformation::Residue {lvalue},unsigned long)

mainchain_torsions(...)


mainchain_torsions( (Residue)arg1) -> vector1_Real :
    Returns the mainchain torsion angles of this residue (const)
    example(s):
        residue.mainchain_torsions()
    See also:
        Residue
        Pose
        Pose.omega
        Pose.phi
        Pose.psi
    

    C++ signature :
        utility::vector1<double, std::allocator<double> > mainchain_torsions(core::conformation::Residue {lvalue})

mainchain_torsions( (Residue)arg1) -> vector1_Real :
    Returns the mainchain torsion angles of this residue (non-const)
    

    C++ signature :
        utility::vector1<double, std::allocator<double> > {lvalue} mainchain_torsions(core::conformation::Residue {lvalue})

mainchain_torsions( (Residue)arg1, (vector1_Real)torsions) -> None :
    Sets the mainchain torsion angles of this residue to  <torsions>
    example(s):
        residue.mainchain_torsions()
    See also:
        Residue
        Pose
        Pose.set_omega
        Pose.set_phi
        Pose.set_psi
    

    C++ signature :
        void mainchain_torsions(core::conformation::Residue {lvalue},utility::vector1<double, std::allocator<double> >)

mm_atom_name(...)


mm_atom_name( (Residue)arg1, (int)atom) -> str :
    Returns the mm_atom_name of this residue's atom with index number  <atom>
    

    C++ signature :
        std::string mm_atom_name(core::conformation::Residue {lvalue},int)

n_bonded_neighbor_all_res(...)


n_bonded_neighbor_all_res( (Residue)arg1, (int)atomno [, (bool)virt=False]) -> int :
    Returns the number of atoms bonded to  <atomno>  in all residues?
    

    C++ signature :
        unsigned long n_bonded_neighbor_all_res(core::conformation::Residue {lvalue},unsigned long [,bool=False])

n_hbond_acceptors(...)


n_hbond_acceptors( (Residue)arg1) -> int :
    number of hbond_donors
    

    C++ signature :
        unsigned long n_hbond_acceptors(core::conformation::Residue {lvalue})

n_hbond_donors(...)


n_hbond_donors( (Residue)arg1) -> int :
    number of hbond_donors
    

    C++ signature :
        unsigned long n_hbond_donors(core::conformation::Residue {lvalue})

n_mainchain_atoms(...)


n_mainchain_atoms( (Residue)arg1) -> int :
    Returns the number of the residue's mainchain atoms
    

    C++ signature :
        unsigned long n_mainchain_atoms(core::conformation::Residue {lvalue})

n_non_polymeric_residue_connections(...)


n_non_polymeric_residue_connections( (Residue)arg1) -> int :
    Returns the number of non-polymeric ResidueConnections on this residue
    

    C++ signature :
        unsigned long n_non_polymeric_residue_connections(core::conformation::Residue {lvalue})

n_nus(...)


n_nus( (Residue)arg1) -> int :
    Return the number of nu (internal ring) angles this residue has.
    Example: residue.n_nus()\n
    See also:\n
        Residue\n
        Residue.nu\n
        Residue.nus\n
        Pose.set_ring_conformation\n
        Pose\n
        Pose.nu
    

    C++ signature :
        unsigned long n_nus(core::conformation::Residue {lvalue})

n_orbitals(...)


n_orbitals( (Residue)arg1) -> int :
    Returns the number of orbitals in this residue
    

    C++ signature :
        unsigned long n_orbitals(core::conformation::Residue {lvalue})

n_polymeric_residue_connections(...)


n_polymeric_residue_connections( (Residue)arg1) -> int :
    Returns the number of polymeric ResidueConnections on this residue
    

    C++ signature :
        unsigned long n_polymeric_residue_connections(core::conformation::Residue {lvalue})

n_residue_connections(...)


n_residue_connections( (Residue)arg1) -> int :
    Returns the number of ResidueConnections on this residue
    including polymeric residue connections
    

    C++ signature :
        unsigned long n_residue_connections(core::conformation::Residue {lvalue})

n_virtual_atoms(...)


n_virtual_atoms( (Residue)arg1) -> int :
    Returns the number of virtual atoms in this residue.
    This calls the function with the same name in ResidueType, which counts virts on the fly (memory-efficient, performance-poor).
    This being the case, don't call this function repeatedly!  Call it once, and store the return value!
    Vikram K. Mulligan (vmullig@uw.edu)
    

    C++ signature :
        unsigned long n_virtual_atoms(core::conformation::Residue {lvalue})

name(...)


name( (Residue)arg1) -> str :
    Returns this residue's ResidueType name
    : for proteins, this will be the amino acid type and variant type
    

    C++ signature :
        std::string name(core::conformation::Residue {lvalue})

name1(...)


name1( (Residue)arg1) -> str :
    Returns this residue's 1-letter representation
    : for proteins, this will be the 1-letter amino acid code
    

    C++ signature :
        char name1(core::conformation::Residue {lvalue})

name3(...)


name3( (Residue)arg1) -> str :
    Returns this residue's 3-letter representation
    : for proteins, this will be the 3-letter amino acid code
    

    C++ signature :
        std::string name3(core::conformation::Residue {lvalue})

natoms(...)


natoms( (Residue)arg1) -> int :
    Returns the number of atoms in this residue
    example(s):
        residue.natoms()
    See also:
        Residue
        Pose
    

    C++ signature :
        unsigned long natoms(core::conformation::Residue {lvalue})

nbr_atom(...)


nbr_atom( (Residue)arg1) -> int :
    Returns the index number of this residue's atom used as a center for neighbor definition
    example: C-beta atom for some amino acids
    

    C++ signature :
        unsigned long nbr_atom(core::conformation::Residue {lvalue})

nbr_atom_xyz(...)


nbr_atom_xyz( (Residue)arg1) -> xyzVector_Real :
    core/conformation/Residue.hh:940

    C++ signature :
        numeric::xyzVector<double> nbr_atom_xyz(core::conformation::Residue {lvalue})

nbr_radius(...)


nbr_radius( (Residue)arg1) -> float :
    Returns the distance cutoff value used as a radius for neighbor definition
    

    C++ signature :
        double nbr_radius(core::conformation::Residue {lvalue})

nbrs(...)


nbrs( (Residue)arg1, (int)atm) -> vector1_Size :
    Convenience synonym for bonded_neighbor
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > nbrs(core::conformation::Residue {lvalue},int)

nchi(...)


nchi( (Residue)arg1) -> int :
    Returns the number of chi angles this residue has
    example(s):
        residue.nchi()
    See also:
        Residue
        Pose
        Pose.chi
        Pose.set_chi
    

    C++ signature :
        unsigned long nchi(core::conformation::Residue {lvalue})

nheavyatoms(...)


nheavyatoms( (Residue)arg1) -> int :
    Returns the number of heavyatoms in this residue
    example(s):
        residue.nheavyatoms()
    See also:
        Residue
        Pose
    

    C++ signature :
        unsigned long nheavyatoms(core::conformation::Residue {lvalue})

nonconst_data_ptr(...)


nonconst_data_ptr( (Residue)arg1) -> BasicDataCache :
    BasicDataCache indexed by enum in residue_datacache.hh
    

    C++ signature :
        boost::shared_ptr<basic::datacache::BasicDataCache> nonconst_data_ptr(core::conformation::Residue {lvalue})

nu(...)


nu( (Residue)arg1, (int)index) -> float :
    Get a specific nu (internal ring) torsion angle by index.
    Example: residue.nu(1)\n
    See also:\n
        Residue\n
        Residue.nus\n
        Residue.n_nus\n
        Pose.set_ring_conformation\n
        Pose\n
        Pose.nu
    It is intentional that there is no set_nu() function; nu angles should only be modified together.
    Use Pose.set_ring_conformation() instead.
    

    C++ signature :
        double nu(core::conformation::Residue {lvalue},unsigned long)

nu_atoms(...)


nu_atoms( (Residue)arg1) -> vec1_vec1_Size :
    Return the AtomIndices of each set of four atoms defining each nu angle.
    

    C++ signature :
        utility::vector1<utility::vector1<unsigned long, std::allocator<unsigned long> >, std::allocator<utility::vector1<unsigned long, std::allocator<unsigned long> > > > nu_atoms(core::conformation::Residue {lvalue})

nu_atoms( (Residue)arg1, (int)index) -> vector1_Size :
    Return the AtomIndices of the four atoms defining the specified nu angle.
    

    C++ signature :
        utility::vector1<unsigned long, std::allocator<unsigned long> > nu_atoms(core::conformation::Residue {lvalue},unsigned long)

nus(...)


nus( (Residue)arg1) -> vector1_Real :
    Return the nu (internal ring) torsion angles of this residue.
    Example: residue.nus()\n
    See also:\n
        Residue\n
        Residue.nu\n
        Residue.n_nus\n
        Pose.set_ring_conformation\n
        Pose\n
        Pose.nu
    

    C++ signature :
        utility::vector1<double, std::allocator<double> > nus(core::conformation::Residue {lvalue})

nus( (Residue)arg1) -> vector1_Real :
    Return the nu (internal ring) torsion angles of this residue. (non-const)
    

    C++ signature :
        utility::vector1<double, std::allocator<double> > {lvalue} nus(core::conformation::Residue {lvalue})

orbital_name(...)


orbital_name( (Residue)arg1, (int)orbital_index) -> str :
    core/conformation/Residue.hh:1016

    C++ signature :
        std::string orbital_name(core::conformation::Residue {lvalue},int)

orbital_type(...)


orbital_type( (Residue)arg1, (int)orbital_index) -> OrbitalType :
    core/conformation/Residue.hh:1021

    C++ signature :
        core::chemical::orbitals::OrbitalType orbital_type(core::conformation::Residue {lvalue},int)

orbital_type_index(...)


orbital_type_index( (Residue)arg1, (int)orbital_index) -> int :
    core/conformation/Residue.hh:1026

    C++ signature :
        unsigned long orbital_type_index(core::conformation::Residue {lvalue},unsigned long)

orbital_xyz(...)


orbital_xyz( (Residue)arg1, (int)orbital_index) -> xyzVector_Real :
    core/conformation/Residue.hh:988

    C++ signature :
        numeric::xyzVector<double> orbital_xyz(core::conformation::Residue {lvalue},unsigned long)

orient_onto_residue(...)


orient_onto_residue( (Residue)arg1, (Residue)src) -> None :
    Orient our coords onto those of  <src>, using the atoms from select_orient_atoms
    

    C++ signature :
        void orient_onto_residue(core::conformation::Residue {lvalue},core::conformation::Residue)

orient_onto_residue( (Residue)arg1, (Residue)src, (vector1_pair_string_string)atom_pairs) -> None :
    core/conformation/Residue.hh:1981

    C++ signature :
        void orient_onto_residue(core::conformation::Residue {lvalue},core::conformation::Residue,utility::vector1<std::pair<std::string, std::string>, std::allocator<std::pair<std::string, std::string> > >)

orient_onto_residue_peptoid(...)


orient_onto_residue_peptoid( (Residue)arg1, (Residue)src, (Conformation)conformation) -> None :
    Orient our coords onto those of src, uses hard coded atom names (yuck) and will work for peptoid on to peptoid/peptide
    

    C++ signature :
        void orient_onto_residue_peptoid(core::conformation::Residue {lvalue},core::conformation::Residue,core::conformation::Conformation)

path_distance(...)


path_distance( (Residue)arg1, (int)atom) -> vector1_int :
    Returns the shortest path distance from  <atom>  to any other atom in this residue
    example(s):
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Pose
    

    C++ signature :
        utility::vector1<int, std::allocator<int> > path_distance(core::conformation::Residue {lvalue},int)

path_distance( (Residue)arg1, (int)at1, (int)at2) -> int :
    Returns the number of bonds separating atom  <at1>  from  <at2>
    example(s):
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.path_distance
        Pose
    

    C++ signature :
        int path_distance(core::conformation::Residue {lvalue},int,int)

path_distances(...)


path_distances( (Residue)arg1) -> vec1_vec1_int :
    Returns the shortest path distance for any atom pair in this residue
    example: path_distances()[atom1][atom2]
    example(s):
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.path_distance
        Pose
    

    C++ signature :
        utility::vector1<utility::vector1<int, std::allocator<int> >, std::allocator<utility::vector1<int, std::allocator<int> > > > path_distances(core::conformation::Residue {lvalue})

place(...)


place( (Residue)arg1, (Residue)src, (Conformation)conformation [, (bool)preserve_c_beta=False]) -> None :
    Place this rotamer at the sequence position occupied by  <src>
    by reorienting the ideal side chain coordinates to match
    

    C++ signature :
        void place(core::conformation::Residue {lvalue},core::conformation::Residue,core::conformation::Conformation [,bool=False])

polymeric_oriented_sequence_distance(...)


polymeric_oriented_sequence_distance( (Residue)arg1, (Residue)other) -> int :
    Returns the sequence separation distance between this residue and  <other>
    positive if the other residue is downstream in sequence
    

    C++ signature :
        int polymeric_oriented_sequence_distance(core::conformation::Residue {lvalue},core::conformation::Residue)

polymeric_sequence_distance(...)


polymeric_sequence_distance( (Residue)arg1, (Residue)other) -> int :
    Returns the sequence separation distance between this residue and  <other>
    : magnitude of distance only
    

    C++ signature :
        unsigned long polymeric_sequence_distance(core::conformation::Residue {lvalue},core::conformation::Residue)

pseudobonds(...)


pseudobonds( (Residue)arg1) -> object :
    core/conformation/Residue.hh:1301

    C++ signature :
        std::map<unsigned long, boost::shared_ptr<core::conformation::PseudoBondCollection const>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, boost::shared_ptr<core::conformation::PseudoBondCollection const> > > > pseudobonds(core::conformation::Residue {lvalue})

requires_actcoord(...)


requires_actcoord( (Residue)arg1) -> bool :
    does this residue require an actcoord?
    

    C++ signature :
        bool requires_actcoord(core::conformation::Residue {lvalue})

residue_connect_atom_index(...)


residue_connect_atom_index( (Residue)arg1, (int)resconn_id) -> int :
    core/conformation/Residue.hh:1154

    C++ signature :
        unsigned long residue_connect_atom_index(core::conformation::Residue {lvalue},unsigned long)

residue_connection(...)


residue_connection( (Residue)arg1, (int)resconn_index) -> ResidueConnection :
    Returns this residue's ResidueConnection
    a ResidueConnection has internal coords info
    on how to build the atom in a different residue which
    connects to this residue
    

    C++ signature :
        core::chemical::ResidueConnection residue_connection(core::conformation::Residue {lvalue},int)

residue_connection_conn_id(...)


residue_connection_conn_id( (Residue)arg1, (int)resconn_index) -> int :
    Returns the connection id on the OTHER residue connected to this residue at this residue's
    connection resconn_index.
    For example, if this were a normally-connected alpha amino acid, residue_connection_conn_id(1)
    would return 2, since the first connection in this residue is attached to the second connection in the
    previous residue.
    

    C++ signature :
        unsigned long residue_connection_conn_id(core::conformation::Residue {lvalue},unsigned long)

residue_connection_partner(...)


residue_connection_partner( (Residue)arg1, (int)resconn_index) -> int :
    Returns the residue number of a residue connected to this residue
    at this residue's connection resconn_index.
    For example, in a normally-connected pose made of alpha-amino
    acids, calling residue_connection_partner(1) on residue 6 should return
    5, since residue 6 is connected to residue 5 at the first connection of
    residue 6.
    

    C++ signature :
        unsigned long residue_connection_partner(core::conformation::Residue {lvalue},unsigned long)

residue_connection_partner( (Residue)arg1, (int)resconn_index, (int)otherres, (int)other_connid) -> None :
    set a connection to this residue by adding its partner's residue number
    

    C++ signature :
        void residue_connection_partner(core::conformation::Residue {lvalue},unsigned long,unsigned long,unsigned long)

residue_type_set(...)


residue_type_set( (Residue)arg1) -> ResidueTypeSet :
    Returns this residue's ResidueTypeSet
    

    C++ signature :
        core::chemical::ResidueTypeSet residue_type_set(core::conformation::Residue {lvalue})

ring_conformer(...)


ring_conformer( (Residue)arg1) -> RingConformer :
    Return the current RingConformer of this residue.
    

    C++ signature :
        core::chemical::RingConformer ring_conformer(core::conformation::Residue {lvalue})

select_orient_atoms(...)


select_orient_atoms( (Residue)arg1, (int)center, (int)nbr1, (int)nbr2) -> None :
    Selects three atoms for orienting this residue
    

    C++ signature :
        void select_orient_atoms(core::conformation::Residue {lvalue},unsigned long {lvalue},unsigned long {lvalue},unsigned long {lvalue})

seqpos(...)


seqpos( (Residue)arg1) -> int :
    Returns the sequence position of this residue
    

    C++ signature :
        unsigned long seqpos(core::conformation::Residue {lvalue})

seqpos( (Residue)arg1, (int)setting) -> None :
    Sets this residue's sequence position to  <setting>
    

    C++ signature :
        void seqpos(core::conformation::Residue {lvalue},unsigned long)

set_all_chi(...)


set_all_chi( (Residue)arg1, (vector1_Real)chis) -> None :
    Sets all of this residue's chi angles using the set_chi function
    (wrapper function)
    

    C++ signature :
        void set_all_chi(core::conformation::Residue {lvalue},utility::vector1<double, std::allocator<double> >)

set_chi(...)


set_chi( (Residue)arg1, (int)chino, (float)setting) -> None :
    Sets this residue's chi angle  <chino>  to  <setting>
    assuming that changes propagate according to the atom_base tree
    

    C++ signature :
        void set_chi(core::conformation::Residue {lvalue},int,double)

set_d(...)


set_d( (Residue)arg1, (int)chino, (float)setting) -> None :
    bondlength analog to set_chi
       like set_chi, assumes changes propagate to atomtree
       keyed off of chi#, so we only allow distances corresponding to chi angles to refine
       distance corresponds to the distance between atoms 3 and 4 defining the chi
       chino==0 ==> CA-CB distance, which allows us to refine ALA CB position for example
    fpd
    

    C++ signature :
        void set_d(core::conformation::Residue {lvalue},int,double)

set_orbital_xyz(...)


set_orbital_xyz( (Residue)arg1, (int)orbital_index, (xyzVector_Real)xyz_in) -> None :
    core/conformation/Residue.hh:994

    C++ signature :
        void set_orbital_xyz(core::conformation::Residue {lvalue},unsigned long,numeric::xyzVector<double>)

set_pseudobonds_to_residue(...)


set_pseudobonds_to_residue( (Residue)arg1, (int)resid, (PseudoBondCollection)pbs) -> None :
    core/conformation/Residue.hh:1307

    C++ signature :
        void set_pseudobonds_to_residue(core::conformation::Residue {lvalue},unsigned long,boost::shared_ptr<core::conformation::PseudoBondCollection const>)

set_theta(...)


set_theta( (Residue)arg1, (int)chino, (float)setting) -> None :
    bondangle analog to set_chi
       same idea as set_d
    fpd
    

    C++ signature :
        void set_theta(core::conformation::Residue {lvalue},int,double)

set_xyz(...)


set_xyz( (Residue)arg1, (int)atm_index, (xyzVector_Real)xyz_in) -> None :
    Sets the position of this residue's atom with index number  <atm_index>
    example(s):
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.xyz
        Pose
    

    C++ signature :
        void set_xyz(core::conformation::Residue {lvalue},unsigned long,numeric::xyzVector<double>)

set_xyz( (Residue)arg1, (str)atm_name, (xyzVector_Real)xyz_in) -> None :
    Sets the position of this residue's atom with name  <atm_name>
    example(s):
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.xyz
        Pose
    

    C++ signature :
        void set_xyz(core::conformation::Residue {lvalue},std::string,numeric::xyzVector<double>)

show(...)


show( (Residue)arg1, (OStream)output [, (bool)output_atomic_details=False]) -> None :
    Generate string representation of Residue for debugging purposes.
    

    C++ signature :
        void show(core::conformation::Residue {lvalue},std::ostream {lvalue} [,bool=False])

sidechainAtoms_begin(...)


sidechainAtoms_begin( (Residue)arg1) -> object :
    should be safe, given the atom ordering rules?
    

    C++ signature :
        __gnu_cxx::__normal_iterator<core::conformation::Atom const*, std::vector<core::conformation::Atom, std::allocator<core::conformation::Atom> > > sidechainAtoms_begin(core::conformation::Residue {lvalue})

type(...)


type( (Residue)arg1) -> ResidueType :
    Returns this residue's ResidueType
    example(s):
        residue.type()
    See also:
        Residue
        Residue.atom_type
    

    C++ signature :
        core::chemical::ResidueType type(core::conformation::Residue {lvalue})

update_actcoord(...)


update_actcoord( (Residue)arg1) -> None :
    Updates actcoord for this residue
    

    C++ signature :
        void update_actcoord(core::conformation::Residue {lvalue})

update_connections_to_other_residue(...)


update_connections_to_other_residue( (Residue)arg1, (Residue)other_rsd) -> None :
    Search through the other residue for connections to this residue, and
    ensure that this residue's connect_map is up to date with that residue's
    connection indices (and residue number).
    Vikram K. Mulligan (vmullig@uw.edu)
    

    C++ signature :
        void update_connections_to_other_residue(core::conformation::Residue {lvalue},core::conformation::Residue)

update_orbital_coords(...)


update_orbital_coords( (Residue)arg1) -> None :
    core/conformation/Residue.hh:1032

    C++ signature :
        void update_orbital_coords(core::conformation::Residue {lvalue})

update_sequence_numbering(...)


update_sequence_numbering( (Residue)arg1, (vector1_Size)old2new) -> None :
    Updates the sequence numbers for this residue and the numbers
    stored about its non-polymer connections
    called by our owning conformation when the sequence numbers are remapped
    

    C++ signature :
        void update_sequence_numbering(core::conformation::Residue {lvalue},utility::vector1<unsigned long, std::allocator<unsigned long> >)

upper_connect(...)


upper_connect( (Residue)arg1) -> ResidueConnection :
    Returns this residue's upper_connection
    a ResidueConnection has internal coords info
    on how to build the atom in the next residue which
    connects to this residue
    

    C++ signature :
        core::chemical::ResidueConnection upper_connect(core::conformation::Residue {lvalue})

upper_connect_atom(...)


upper_connect_atom( (Residue)arg1) -> int :
    Returns the index number of this residue's atom which connects to
    the residue after it in sequence
    : polymers only, example: for an amino acid, residue.upper_connect_atom() = atom_index("C")
    example(s):
        residue.upper_connect_atom()
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.lower_connect_atom
        Pose
    

    C++ signature :
        unsigned long upper_connect_atom(core::conformation::Residue {lvalue})

xyz(...)


xyz( (Residue)arg1, (int)atm_index) -> xyzVector_Real :
    Returns the position of this residue's atom with index number  <atm_index>
    : position is a Vector
    example(s):
        residue.xyz(3)
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.set_xyz
        Pose
    

    C++ signature :
        numeric::xyzVector<double> xyz(core::conformation::Residue {lvalue},unsigned long)

xyz( (Residue)arg1, (str)atm_name) -> xyzVector_Real :
    Returns the position of this residue's atom with name  <atm_name>
    : position is a Vector
    example(s):
        residue.xyz("CA")
    See also:
        Residue
        Residue.atom
        Residue.atoms
        Residue.set_xyz
        Pose
    

    C++ signature :
        numeric::xyzVector<double> xyz(core::conformation::Residue {lvalue},std::string)

Class Residue

Haro_index(...)

Hpol_index(...)

Hpos_apolar(...)

Hpos_polar(...)

Hpos_polar_sc(...)

RNA_type(...)

__init__(...) (Constructor)

__reduce__(...)

__str__(...) (Informal representation operator)

aa(...)

abase2(...)

accpt_pos(...)

accpt_pos_sc(...)

actcoord(...)

actcoord_atoms(...)

actual_residue_connection(...)

all_bb_atoms(...)

apply_transform_Rx_plus_v(...)

atom(...)

atom_base(...)

atom_begin(...)

atom_end(...)

atom_index(...)

atom_is_backbone(...)

atom_is_hydrogen(...)

atom_is_polar_hydrogen(...)

atom_name(...)

atom_type(...)

atom_type_index(...)

atom_type_set(...)

atomic_charge(...)

atoms(...)

atoms_with_orb_index(...)

attached_H_begin(...)

attached_H_end(...)

backbone_aa(...)

bonded_neighbor(...)

bonded_orbitals(...)

build_atom_ideal(...)

build_orbital_xyz(...)

carbohydrate_info(...)

chain(...)

chi(...)

chi_atoms(...)

chi_rotamers(...)

clear_residue_connections(...)

clone(...)

connect_atom(...)

connect_map(...)

connect_map_size(...)

connected_residue_at_resconn(...)

connection_distance(...)

connection_incomplete(...)

connections_match(...)

connections_to_residue(...)

copy_residue_connections(...)

copy_residue_connections_from(...)

create_residue(...)

create_rotamer(...)

cut_bond_neighbor(...)

data_ptr(...)

fill_missing_atoms(...)

first_sidechain_atom(...)

first_sidechain_hydrogen(...)

get_metal_binding_atoms(...)

get_pseudobonds_to_residue(...)

get_self_ptr(...)

get_self_weak_ptr(...)

has(...)

has_incomplete_connection(...)

has_lower_connect(...)

has_property(...)

has_sc_orbitals(...)

has_upper_connect(...)

has_variant_type(...)

heavyAtoms_end(...)

heavyatom_has_polar_hydrogens(...)

heavyatom_is_an_acceptor(...)

icoor(...)

init(...)
(Constructor)

reduce(...)

str(...)
(Informal representation operator)