Class Frame

__init__( (object)arg1) -> None :

    C++ signature :
        void __init__(_object*)

__init__( (object)arg1, (Frame)) -> None :
    Frame couples a list of FragData-instances to a certain alignment frame, i.e., position in sequence space
    @detail A frame may be continous, i.e., its fragment data will be applied to all residues between start() and end()
    or ( in a specialized version inheriting this interface) may contain a loose list of sequence positions.
    Instances of FragData (e.g., the Torsion-Angles of a specific Fragment) can be
    added and deleted via add_- or delete_fragment() methods.
    a fragment is inserted into the structure via the apply() method
    and the steal() method is its inverse: an instance of FragData is created from the structure of the pose
    at the dof's specified in the other FragData's of the Frame. The new FragData is added as last fragment to the frame.
    accessors to underlying FragData-instances are available as fragment() or fragment_ptr().
    Frame supports the FragCache --> see FragCache for documentation.
    MoveMaps: It should be possible to specify which dofs can be moved. In this case fragment-insertions should
    a) only be allowed if all dofs affected are moveable or b) only change those dofs that are moveable.
    this information could be handled by an extended version of the kinematics::movemap.
    The movemap would then have to functions: 1) which dofs are changed by a certain FragData/Frame
                                              2) which dofs are moveable
                                comparison of movemaps, i.e., M1 <= M2 could tell us if dofs tagged in M1 are also tagged in M2:
                          i.e., the M_fragdata<= M_pose would tell us that the fragment is applicable to the Pose.
    

    C++ signature :
        void __init__(_object*,core::fragment::Frame)

__init__( (object)arg1, (int)begin, (int)end, (int)nr_res) -> None :
    core/fragment/Frame.hh:110

    C++ signature :
        void __init__(_object*,unsigned long,unsigned long,unsigned long)

__init__( (object)arg1, (int)start, (int)length) -> None :
    core/fragment/Frame.hh:112

    C++ signature :
        void __init__(_object*,unsigned long,unsigned long)

__init__( (object)arg1, (int)start) -> None :
    core/fragment/Frame.hh:114

    C++ signature :
        void __init__(_object*,unsigned long)

__init__( (object)arg1, (int)start, (__CPP_FragData__)frag1) -> None :
    core/fragment/Frame.hh:116

    C++ signature :
        void __init__(_object*,unsigned long,boost::shared_ptr<core::fragment::FragData const>)

__init__( (object)arg1, (int)start, (int)length, (__CPP_SingleResidueFragData__)srfd) -> None :
    core/fragment/Frame.hh:118

    C++ signature :
        void __init__(_object*,unsigned long,unsigned long,boost::shared_ptr<core::fragment::SingleResidueFragData>)

Overrides: object.__init__

helper for pickle

Overrides: object.__reduce__

(inherited documentation)

__str__( (Frame)arg1) -> object :

    C++ signature :
        _object* __str__(core::fragment::Frame {lvalue})

Overrides: object.__str__

add_fragment( (Frame)arg1, (__CPP_FragData__)new_frag) -> int :
    add a fragment .. return new frag_nr
    

    C++ signature :
        unsigned long add_fragment(core::fragment::Frame {lvalue},boost::shared_ptr<core::fragment::FragData const>)

add_fragment( (Frame)arg1, (object)new_frags) -> bool :
    add all fragments in list
    

    C++ signature :
        bool add_fragment(core::fragment::Frame {lvalue},utility::vector1<boost::shared_ptr<core::fragment::FragData const>, std::allocator<boost::shared_ptr<core::fragment::FragData const> > >)

align( (Frame)arg1, (SequenceMapping)map) -> bool :
    change frames residue numbers accoriding to map
    

    C++ signature :
        bool align(core::fragment::Frame {lvalue},core::id::SequenceMapping)

align( (Frame)arg1, (SequenceMapping)map) -> bool :

    C++ signature :
        bool align(Frame_exposer_callback {lvalue},core::id::SequenceMapping)

apply( (Frame)arg1, (MoveMap), (int)frag_num, (Pose)pose) -> int :
    insert fragment frag_num into pose
    

    C++ signature :
        unsigned long apply(core::fragment::Frame {lvalue},core::kinematics::MoveMap,unsigned long,core::pose::Pose {lvalue})

apply( (Frame)arg1, (int)frag_num, (Pose)pose) -> int :
    insert fragment frag_num into pose --- ignore movemap
    

    C++ signature :
        unsigned long apply(core::fragment::Frame {lvalue},unsigned long,core::pose::Pose {lvalue})

apply_ss( (Frame)arg1, (MoveMap), (int)frag_num, (str)ss) -> int :
    change ss-string according to sec-struct info in fragments
    

    C++ signature :
        unsigned long apply_ss(core::fragment::Frame {lvalue},core::kinematics::MoveMap,unsigned long,std::string {lvalue})

cache( (Frame)arg1, (str)tag, (__CPP_BaseCacheUnit__)new_cache) -> BaseCacheUnit :
    return handle to cached data stored under "tag"
    shouldn't be called directly
    

    C++ signature :
        core::fragment::BaseCacheUnit {lvalue} cache(core::fragment::Frame {lvalue},std::string,boost::shared_ptr<core::fragment::BaseCacheUnit>)

clear( (Frame)arg1) -> None :
    remove all valid fragments, a template fragment will be left over
    

    C++ signature :
        void clear(core::fragment::Frame {lvalue})

clone( (Frame)arg1) -> Frame :
    clone method, new frame with same alignment position, fragments are not copied!
    

    C++ signature :
        boost::shared_ptr<core::fragment::Frame> clone(core::fragment::Frame {lvalue})

clone( (Frame)arg1) -> Frame :

    C++ signature :
        boost::shared_ptr<core::fragment::Frame> clone(Frame_exposer_callback {lvalue})

clone_cache_data( (Frame)arg1, (Frame)source, (int)sid, (int)nid) -> None :
    copies all entries in the Frame-Cache for fragment "sid" of Frame "source" to fragment "nid" of "this" frame
    

    C++ signature :
        void clone_cache_data(core::fragment::Frame {lvalue},core::fragment::Frame,unsigned long,unsigned long)

clone_with_frags( (Frame)arg1) -> Frame :
    clone method, new frame with same alignment position, fragments are not copied!
    

    C++ signature :
        boost::shared_ptr<core::fragment::Frame> clone_with_frags(core::fragment::Frame {lvalue})

clone_with_frags( (Frame)arg1) -> Frame :

    C++ signature :
        boost::shared_ptr<core::fragment::Frame> clone_with_frags(Frame_exposer_callback {lvalue})

clone_with_template( (Frame)arg1) -> Frame :
    clone method, new frame with same alignment position, one fragments is copied as template ( valid() == false )
    

    C++ signature :
        boost::shared_ptr<core::fragment::Frame> clone_with_template(core::fragment::Frame {lvalue})

clone_with_template( (Frame)arg1) -> Frame :

    C++ signature :
        boost::shared_ptr<core::fragment::Frame> clone_with_template(Frame_exposer_callback {lvalue})

contains_seqpos( (Frame)arg1, (int)seqpos) -> bool :
    whether this fragment contains a certain position
    

    C++ signature :
        bool contains_seqpos(core::fragment::Frame {lvalue},unsigned long)

end( (Frame)arg1) -> int :
    last sequence position affected by this frame
    

    C++ signature :
        unsigned long end(core::fragment::Frame {lvalue})

frag_id( (Frame)arg1, (int)frag_num) -> int :
    a unique id for every fragment in the list.
    his is silly, but would enable later on to avoid cache_clearence on deletion of FragData entries
    in this case, we would require that the ID of a certain fragment never changes, even if the position in FragList changes
    

    C++ signature :
        unsigned long frag_id(core::fragment::Frame {lvalue},unsigned long)

fragment( (Frame)arg1, (int)frag_num) -> FragData :
    accesors for underlying FragData
    

    C++ signature :
        core::fragment::FragData fragment(core::fragment::Frame {lvalue},unsigned long)

fragment_as_pose( (Frame)arg1, (int)frag_num, (Pose)pose, (ResidueTypeSetCAP)restype_set) -> None :
    returns a (small) pose with fragment ( continous from seqpos 1 ... nr_res_affected() )
    

    C++ signature :
        void fragment_as_pose(core::fragment::Frame {lvalue},unsigned long,core::pose::Pose {lvalue},boost::weak_ptr<core::chemical::ResidueTypeSet const>)

fragment_ptr( (Frame)arg1, (int)frag_num) -> FragData :
    accessor for underlying FragData as owning ptr
    

    C++ signature :
        boost::shared_ptr<core::fragment::FragData const> fragment_ptr(core::fragment::Frame {lvalue},unsigned long)

generate_sub_frame( (Frame)arg1, (int)length [, (int)start=1]) -> Frame :
    generate_sub_frame of length from start ( internal numbers )
    

    C++ signature :
        boost::shared_ptr<core::fragment::Frame> generate_sub_frame(core::fragment::Frame {lvalue},unsigned long [,unsigned long=1])

is_applicable( (Frame)arg1, (MoveMap)) -> int :
    is the Frame applicable to the pose with the given movemap?
    

    C++ signature :
        unsigned long is_applicable(core::fragment::Frame {lvalue},core::kinematics::MoveMap)

is_continuous( (Frame)arg1) -> bool :
    /////// properties of the Frame///////////////////
     true if frame is continuous (always true for base class)
    

    C++ signature :
        bool is_continuous(core::fragment::Frame {lvalue})

is_continuous( (Frame)arg1) -> bool :

    C++ signature :
        bool is_continuous(Frame_exposer_callback {lvalue})

is_mergeable( (Frame)arg1, (Frame)other) -> bool :
    core/fragment/Frame.hh:263

    C++ signature :
        bool is_mergeable(core::fragment::Frame {lvalue},core::fragment::Frame)

is_valid( (Frame)arg1) -> bool :
    a frame is considered valid if at least one fragment is contained and this fragment is also valid
    (not an empty template fragment)
    

    C++ signature :
        bool is_valid(core::fragment::Frame {lvalue})

length( (Frame)arg1) -> int :
    number of residues in this frame ( for continuous frames it is the same as end()-start() + 1 )
    

    C++ signature :
        unsigned long length(core::fragment::Frame {lvalue})

merge( (Frame)arg1, (Frame)other) -> bool :
    core/fragment/Frame.hh:265

    C++ signature :
        bool merge(core::fragment::Frame {lvalue},core::fragment::Frame)

moves_residue( (Frame)arg1, (int)pos) -> bool :
    core/fragment/Frame.hh:232

    C++ signature :
        bool moves_residue(core::fragment::Frame {lvalue},unsigned long)

moves_residue( (Frame)arg1, (int)pos) -> bool :

    C++ signature :
        bool moves_residue(Frame_exposer_callback {lvalue},unsigned long)

nr_frags( (Frame)arg1) -> int :
    number of fragments attached to this frame
    

    C++ signature :
        unsigned long nr_frags(core::fragment::Frame {lvalue})

nr_res_affected( (Frame)arg1, (MoveMap)mm) -> int :
    number of residues affected by this frame
    

    C++ signature :
        unsigned long nr_res_affected(core::fragment::Frame {lvalue},core::kinematics::MoveMap)

read( (Frame)arg1, (std_istream)in) -> None :
    core/fragment/Frame.hh:261

    C++ signature :
        void read(core::fragment::Frame {lvalue},std::istream {lvalue})

read( (Frame)arg1, (std_istream)in) -> None :

    C++ signature :
        void read(Frame_exposer_callback {lvalue},std::istream {lvalue})

seqpos( (Frame)arg1, (int)intra_pos) -> int :
    translate intra-frame position into sequence position. (trivial for base-class)
    

    C++ signature :
        unsigned long seqpos(core::fragment::Frame {lvalue},unsigned long)

seqpos( (Frame)arg1, (int)intra_pos) -> int :

    C++ signature :
        unsigned long seqpos(Frame_exposer_callback {lvalue},unsigned long)

shift_by( (Frame)arg1, (int)offset) -> None :
    shift frame by offset relative to current start position ( change end accordingly )
    

    C++ signature :
        void shift_by(core::fragment::Frame {lvalue},int)

shift_by( (Frame)arg1, (int)offset) -> None :

    C++ signature :
        void shift_by(Frame_exposer_callback {lvalue},int)

shift_to( (Frame)arg1, (int)setting) -> None :
    shift to new start position ( change end accordingly )
    

    C++ signature :
        void shift_to(core::fragment::Frame {lvalue},unsigned long)

shift_to( (Frame)arg1, (int)setting) -> None :

    C++ signature :
        void shift_to(Frame_exposer_callback {lvalue},unsigned long)

show( (Frame)arg1, (OStream)out) -> None :
    core/fragment/Frame.hh:255

    C++ signature :
        void show(core::fragment::Frame {lvalue},std::ostream {lvalue})

show( (Frame)arg1, (OStream)out) -> None :

    C++ signature :
        void show(Frame_exposer_callback {lvalue},std::ostream {lvalue})

show_classic( (Frame)arg1, (OStream)out) -> None :
    core/fragment/Frame.hh:251

    C++ signature :
        void show_classic(core::fragment::Frame {lvalue},std::ostream {lvalue})

show_classic( (Frame)arg1, (OStream)out) -> None :

    C++ signature :
        void show_classic(Frame_exposer_callback {lvalue},std::ostream {lvalue})

show_header( (Frame)arg1, (OStream)out) -> None :
    core/fragment/Frame.hh:258

    C++ signature :
        void show_header(core::fragment::Frame {lvalue},std::ostream {lvalue})

show_header( (Frame)arg1, (OStream)out) -> None :

    C++ signature :
        void show_header(Frame_exposer_callback {lvalue},std::ostream {lvalue})

start( (Frame)arg1) -> int :
    first seqpos of this frame
    

    C++ signature :
        unsigned long start(core::fragment::Frame {lvalue})

steal( (Frame)arg1, (Pose)pose) -> bool :
    obtain fragment from pose at frame position
    

    C++ signature :
        bool steal(core::fragment::Frame {lvalue},core::pose::Pose)

stop( (Frame)arg1) -> int :
    last sequence position affected by this frame
    

    C++ signature :
        unsigned long stop(core::fragment::Frame {lvalue})

type( (Frame)arg1) -> str :
    type() is specifying the output name of the Frame in FragmentIO ("FRAME", "JUMPFRAME", etc)
    

    C++ signature :
        std::string type(core::fragment::Frame {lvalue})

type( (Frame)arg1) -> str :

    C++ signature :
        std::string type(Frame_exposer_callback {lvalue})