Class ResidueConnection

__init__( (object)arg1) -> None :

    C++ signature :
        void __init__(_object*)

__init__( (object)arg1, (ResidueConnection)) -> None :
    A simple class marking atoms at inter-residue connections.
    Each residue type specifies some number of positions at which it is expecting
    to form a chemical bond with another residue. Think of them as ports: they are
    parts of the residue where there are chemical bonds beyond the intra-residue
    chemical bonds are expected -- places where they can be chemically linked
    to the outside world.  A conformation::Residue will require that its
    ResidueConnections be fulfilled by other Residues -- the ResConnID class
    describes how two residues are connected: e.g., the third ResConnID for
    residue 10 would say "I connect to residue 58 at residue 58's third residue
    connection" if residue 10 and residue 58 were disulfide bonded as the disulfide
    connection id is "3" for two mid-protein cystine residues.  The advantages
    of separating ResidueConnections from atoms themselves are that 1) it allows
    multiple residue connections to stem from the same atom -- useful for single-atom
    residues, such as coordinated metals (Zn, Mg), and 2) it allows one residue
    to change its set of atoms without invalidating the bond information (e.g. the atom
    index) on its partner.  For example, if a chain-break were placed between residues
    57 and 58, then residue 58 will get an extra C-prev virtual atom, and the index of
    SG will change.  Residue 10, if it had recorded the SG index would have to find
    SG's new index.  If instead, the connection point is represented simply as
    connection point 3, and if the new residue type (the chainbreak disulfide residue)
    has the same number of residue connections as the original residue type (it will!)
    then nothing about residue 10 needs to be updated.
    

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

__init__( (object)arg1, (int)atomno_in, (object)vertex) -> None :
    constructor with atom index number
    

    C++ signature :
        void __init__(_object*,int,void*)

Overrides: object.__init__

helper for pickle

Overrides: object.__reduce__

(inherited documentation)

atomno( (ResidueConnection)arg1) -> int :
    get atom index number
    

    C++ signature :
        int atomno(core::chemical::ResidueConnection {lvalue})

atomno( (ResidueConnection)arg1, (int)atomno_in) -> None :
    set atom index number
    

    C++ signature :
        void atomno(core::chemical::ResidueConnection {lvalue},unsigned long)

icoor( (ResidueConnection)arg1) -> AtomICoor :
    get atom's AtomICoor
    

    C++ signature :
        core::chemical::AtomICoor icoor(core::chemical::ResidueConnection {lvalue})

icoor( (ResidueConnection)arg1, (AtomICoor)ic) -> None :
    set atom's AtomICoor
    

    C++ signature :
        void icoor(core::chemical::ResidueConnection {lvalue},core::chemical::AtomICoor)

index( (ResidueConnection)arg1) -> int :
    core/chemical/ResidueConnection.hh:147

    C++ signature :
        int index(core::chemical::ResidueConnection {lvalue})

index( (ResidueConnection)arg1, (int)index_in) -> None :
    core/chemical/ResidueConnection.hh:148

    C++ signature :
        void index(core::chemical::ResidueConnection {lvalue},int)

vertex( (ResidueConnection)arg1) -> object :
    get the vetex associated with this residue connection
    

    C++ signature :
        void* vertex(core::chemical::ResidueConnection {lvalue})

vertex( (ResidueConnection)arg1, (object)vertex) -> None :
    set the vertex of this residue connection
    

    C++ signature :
        void vertex(core::chemical::ResidueConnection {lvalue},void*)