Bindings for core::fragment namespace

Modules
		rosetta.core.fragment.picking_old

Classes
		builtins.object BaseCacheUnit FragData AnnotatedFragData FragFactory FragID FragID_Iterator FragSet ConstantLengthFragSet FragSetCollection MinimalFragSet OrderedFragSet FragmentIO FragmentRmsd Frame NonContinuousFrame JumpingFrame FrameIteratorWorker_ ConstantLengthFragSetIterator_ FrameListIterator_ MinimalFragSetIterator_ OrderedFragSetIterator_ SecondaryStructure SingleResidueFragData DownJumpSRFD SecstructSRFD BBTorsionSRFD BBTorsionAndAnglesSRFD IndependentBBTorsionSRFD UpJumpSRFD torsions rosetta.std.iterator_std_forward_iterator_tag_core_fragment_Frame_long_core_fragment_Frame_*_core_fragment_Frame_&_t(builtins.object) ConstFrameIterator FrameIterator rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t(builtins.object) FrameList   class AnnotatedFragData(FragData)     FragData that contains additional information     Method resolution order: AnnotatedFragData FragData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle, str, int) -> NoneType   doc   2. __init__(self : handle, pdb_id : str, start_pos : int, chain : str) -> NoneType   3. __init__(handle, str, int, rosetta.core.fragment.FragData) -> NoneType   doc   4. __init__(self : handle, pdb_id : str, start_pos : int, frag : rosetta.core.fragment.FragData, chain : str) -> NoneType   5. __init__(handle, rosetta.core.fragment.AnnotatedFragData) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.AnnotatedFragData,  : rosetta.core.fragment.AnnotatedFragData) -> rosetta.core.fragment.AnnotatedFragData chain(...) from builtins.PyCapsule chain(rosetta.core.fragment.AnnotatedFragData) -> str clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.AnnotatedFragData) -> rosetta.core.fragment.FragData copy(...) from builtins.PyCapsule copy(self : rosetta.core.fragment.AnnotatedFragData, frag_data : rosetta.core.fragment.FragData) -> NoneType generate_sub_fragment(...) from builtins.PyCapsule generate_sub_fragment(self : rosetta.core.fragment.AnnotatedFragData, start : int, stop : int) -> rosetta.core.fragment.FragData pdbid(...) from builtins.PyCapsule pdbid(rosetta.core.fragment.AnnotatedFragData) -> str pdbpos(...) from builtins.PyCapsule pdbpos(rosetta.core.fragment.AnnotatedFragData) -> int Methods inherited from FragData: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.FragData) -> str add_residue(...) from builtins.PyCapsule add_residue(self : rosetta.core.fragment.FragData, res : rosetta.core.fragment.SingleResidueFragData) -> NoneType apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap,  : core::pose::Pose, start : int, end : int) -> int   2. apply(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap,  : core::pose::Pose,  : rosetta.core.fragment.Frame) -> int   3. apply(self : rosetta.core.fragment.FragData,  : core::pose::Pose,  : rosetta.core.fragment.Frame) -> int   4. apply(self : rosetta.core.fragment.FragData,  : core::pose::Pose, start : int, end : int) -> int apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap, ss : str,  : rosetta.core.fragment.Frame) -> int get_residue(...) from builtins.PyCapsule get_residue(self : rosetta.core.fragment.FragData, pos : int) -> rosetta.core.fragment.SingleResidueFragData get_self_ptr(...) from builtins.PyCapsule get_self_ptr(*args, **kwargs) Overloaded function.   1. get_self_ptr(rosetta.core.fragment.FragData) -> rosetta.core.fragment.FragData   self pointers   2. get_self_ptr(rosetta.core.fragment.FragData) -> rosetta.core.fragment.FragData is_applicable(...) from builtins.PyCapsule is_applicable(*args, **kwargs) Overloaded function.   1. is_applicable(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap, start : int, end : int) -> int   2. is_applicable(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap,  : rosetta.core.fragment.Frame) -> int is_compatible(...) from builtins.PyCapsule is_compatible(self : rosetta.core.fragment.FragData, frag_data : rosetta.core.fragment.FragData) -> bool is_valid(...) from builtins.PyCapsule is_valid(rosetta.core.fragment.FragData) -> bool score(...) from builtins.PyCapsule score(rosetta.core.fragment.FragData) -> float   Returns the score for this fragment secstruct(...) from builtins.PyCapsule secstruct(*args, **kwargs) Overloaded function.   1. secstruct(self : rosetta.core.fragment.FragData, pos : int) -> str   2. secstruct(rosetta.core.fragment.FragData) -> str sequence(...) from builtins.PyCapsule sequence(*args, **kwargs) Overloaded function.   1. sequence(self : rosetta.core.fragment.FragData, pos : int) -> str   2. sequence(rosetta.core.fragment.FragData) -> str set_residue(...) from builtins.PyCapsule set_residue(self : rosetta.core.fragment.FragData, pos : int, res : rosetta.core.fragment.SingleResidueFragData) -> NoneType set_score(...) from builtins.PyCapsule set_score(self : rosetta.core.fragment.FragData, score : float) -> NoneType   Set a score value for this fragment set_sequence(...) from builtins.PyCapsule set_sequence(self : rosetta.core.fragment.FragData, pos : int, setting : str) -> NoneType set_valid(...) from builtins.PyCapsule set_valid(*args, **kwargs) Overloaded function.   1. set_valid(rosetta.core.fragment.FragData) -> NoneType   2. set_valid(self : rosetta.core.fragment.FragData, setting : bool) -> NoneType size(...) from builtins.PyCapsule size(rosetta.core.fragment.FragData) -> int steal(...) from builtins.PyCapsule steal(*args, **kwargs) Overloaded function.   1. steal(self : rosetta.core.fragment.FragData,  : core::pose::Pose, start : int, end : int) -> bool   2. steal(self : rosetta.core.fragment.FragData,  : core::pose::Pose,  : rosetta.core.fragment.Frame) -> bool   class BBTorsionAndAnglesSRFD(BBTorsionSRFD)       Method resolution order: BBTorsionAndAnglesSRFD BBTorsionSRFD SecstructSRFD SingleResidueFragData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.utility.vector1_std_pair_std_vector_unsigned_long_std_allocator_unsigned_long_double_t) -> NoneType   doc   3. __init__(handle, rosetta.utility.vector1_std_pair_std_vector_unsigned_long_std_allocator_unsigned_long_double_t, int) -> NoneType   doc   4. __init__(handle, rosetta.utility.vector1_std_pair_std_vector_unsigned_long_std_allocator_unsigned_long_double_t, int, str) -> NoneType   doc   5. __init__(self : handle, angles_in : rosetta.utility.vector1_std_pair_std_vector_unsigned_long_std_allocator_unsigned_long_double_t, nbb_in : int, secstruct : str, sequence : str) -> NoneType   6. __init__(handle, rosetta.core.fragment.BBTorsionAndAnglesSRFD) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.BBTorsionAndAnglesSRFD,  : core::pose::Pose, seq_pos : int) -> bool   2. apply(self : rosetta.core.fragment.BBTorsionAndAnglesSRFD, movemap : core::kinematics::MoveMap, pose : core::pose::Pose, seqpos : int) -> bool   insert backbone torsions and angles into pose at position seqpos   if all bb torsions are moveable in MoveMap      True if *all* torsions and angles are inserted and superclass apply()   is successful, otherwise False.      This is currently all or nothing -- all torsions for seqpos   must be moveable because it's not entirely clear what the behavior   of partial angle insertion is.  In addition, DOF_IDs are not made   explicitly available within this class, meaning there is no way to   look them up within the MoveMap; the implementation in this class   must be changed if this is desired. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.BBTorsionAndAnglesSRFD,  : rosetta.core.fragment.BBTorsionAndAnglesSRFD) -> rosetta.core.fragment.BBTorsionAndAnglesSRFD clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.BBTorsionAndAnglesSRFD) -> rosetta.core.fragment.SingleResidueFragData create(...) from builtins.PyCapsule create(rosetta.core.fragment.BBTorsionAndAnglesSRFD) -> rosetta.core.fragment.SingleResidueFragData   create a new instance of this object is_applicable(...) from builtins.PyCapsule is_applicable(self : rosetta.core.fragment.BBTorsionAndAnglesSRFD,  : core::kinematics::MoveMap, seq_pos : int) -> bool is_compatible(...) from builtins.PyCapsule is_compatible(self : rosetta.core.fragment.BBTorsionAndAnglesSRFD,  : rosetta.core.fragment.SingleResidueFragData) -> bool nangles(...) from builtins.PyCapsule nangles(rosetta.core.fragment.BBTorsionAndAnglesSRFD) -> int steal(...) from builtins.PyCapsule steal(self : rosetta.core.fragment.BBTorsionAndAnglesSRFD,  : core::pose::Pose, seq_pos : int) -> bool type(...) from builtins.PyCapsule type(rosetta.core.fragment.BBTorsionAndAnglesSRFD) -> str Methods inherited from BBTorsionSRFD: has_coordinates(...) from builtins.PyCapsule has_coordinates(rosetta.core.fragment.BBTorsionSRFD) -> bool   Returns true if this instance contains cartesian coordinates,  false otherwise. Coordinates are available if the <write_ca_coords>  option is enabled in the new fragment picker and rosetta++ fragments  are used. nbb(...) from builtins.PyCapsule nbb(rosetta.core.fragment.BBTorsionSRFD) -> int   number of backbone torsions described by this fragment set_coordinates(...) from builtins.PyCapsule set_coordinates(self : rosetta.core.fragment.BBTorsionSRFD, x : float, y : float, z : float) -> NoneType   Convenience method for setting this residue's  CA coordinates all at once set_torsion(...) from builtins.PyCapsule set_torsion(self : rosetta.core.fragment.BBTorsionSRFD, tor : int, setting : float) -> NoneType   set value for specific torsion in this piece of fragment. torsion(...) from builtins.PyCapsule torsion(self : rosetta.core.fragment.BBTorsionSRFD, torsion_number : int) -> float   get the value for a specific torsion in this fragment x(...) from builtins.PyCapsule x(rosetta.core.fragment.BBTorsionSRFD) -> float   Returns the x coordinate of this residue's CA y(...) from builtins.PyCapsule y(rosetta.core.fragment.BBTorsionSRFD) -> float   Returns the y coordinate of this residue's CA z(...) from builtins.PyCapsule z(rosetta.core.fragment.BBTorsionSRFD) -> float   Returns the z coordinate of this residue's CA Methods inherited from SecstructSRFD: apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.SecstructSRFD,  : str, seq_pos : int) -> bool secstruct(...) from builtins.PyCapsule secstruct(rosetta.core.fragment.SecstructSRFD) -> str   get secstruct for this position set_secstruct(...) from builtins.PyCapsule set_secstruct(self : rosetta.core.fragment.SecstructSRFD, ss : str) -> NoneType Methods inherited from SingleResidueFragData: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.SingleResidueFragData) -> str sequence(...) from builtins.PyCapsule sequence(rosetta.core.fragment.SingleResidueFragData) -> str set_sequence(...) from builtins.PyCapsule set_sequence(self : rosetta.core.fragment.SingleResidueFragData, sequence : str) -> NoneType   class BBTorsionSRFD(SecstructSRFD)       Method resolution order: BBTorsionSRFD SecstructSRFD SingleResidueFragData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   doc   2. __init__(handle, int) -> NoneType   doc   3. __init__(handle, int, str) -> NoneType   doc   4. __init__(self : handle, nbb_in : int, secstruct : str, sequence : str) -> NoneType   5. __init__(handle, rosetta.core.fragment.BBTorsionSRFD) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.BBTorsionSRFD,  : core::pose::Pose, seq_pos : int) -> bool   insert all backbone torsions into pose at position seq_pos   2. apply(self : rosetta.core.fragment.BBTorsionSRFD, movemap : core::kinematics::MoveMap, pose : core::pose::Pose, seqpos : int) -> bool   insert all backbone torsions into pose at position seq_pos      This MoveMap will be *ignored* at the BBTorsionSRFD level,   but will be passed to any superclass apply().      The pose to modify.      Sequence position to modify.      True if apply() successful, False otherwise.      MoveMap settings at the BBTorsionSRFD level are *ignored*.   For speed, does not check to see whether or not all backbone torsions   are moveable in MoveMap -- use is_applicable() for this   purpose prior to calling apply(). assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.BBTorsionSRFD, rval : rosetta.core.fragment.BBTorsionSRFD) -> rosetta.core.fragment.BBTorsionSRFD   copy assignment clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.BBTorsionSRFD) -> rosetta.core.fragment.SingleResidueFragData   clone this object create(...) from builtins.PyCapsule create(rosetta.core.fragment.BBTorsionSRFD) -> rosetta.core.fragment.SingleResidueFragData   create a new instance of this object has_coordinates(...) from builtins.PyCapsule has_coordinates(rosetta.core.fragment.BBTorsionSRFD) -> bool   Returns true if this instance contains cartesian coordinates,  false otherwise. Coordinates are available if the <write_ca_coords>  option is enabled in the new fragment picker and rosetta++ fragments  are used. is_applicable(...) from builtins.PyCapsule is_applicable(self : rosetta.core.fragment.BBTorsionSRFD,  : core::kinematics::MoveMap, seq_pos : int) -> bool   check if all backbone torsions at the sequence position moveable   in the MoveMap      True if all backbone torsions moveable and is_applicable()   succeeded for superclass, otherwise False. is_compatible(...) from builtins.PyCapsule is_compatible(self : rosetta.core.fragment.BBTorsionSRFD,  : rosetta.core.fragment.SingleResidueFragData) -> bool nbb(...) from builtins.PyCapsule nbb(rosetta.core.fragment.BBTorsionSRFD) -> int   number of backbone torsions described by this fragment set_coordinates(...) from builtins.PyCapsule set_coordinates(self : rosetta.core.fragment.BBTorsionSRFD, x : float, y : float, z : float) -> NoneType   Convenience method for setting this residue's  CA coordinates all at once set_torsion(...) from builtins.PyCapsule set_torsion(self : rosetta.core.fragment.BBTorsionSRFD, tor : int, setting : float) -> NoneType   set value for specific torsion in this piece of fragment. steal(...) from builtins.PyCapsule steal(self : rosetta.core.fragment.BBTorsionSRFD,  : core::pose::Pose, seq_pos : int) -> bool torsion(...) from builtins.PyCapsule torsion(self : rosetta.core.fragment.BBTorsionSRFD, torsion_number : int) -> float   get the value for a specific torsion in this fragment type(...) from builtins.PyCapsule type(rosetta.core.fragment.BBTorsionSRFD) -> str x(...) from builtins.PyCapsule x(rosetta.core.fragment.BBTorsionSRFD) -> float   Returns the x coordinate of this residue's CA y(...) from builtins.PyCapsule y(rosetta.core.fragment.BBTorsionSRFD) -> float   Returns the y coordinate of this residue's CA z(...) from builtins.PyCapsule z(rosetta.core.fragment.BBTorsionSRFD) -> float   Returns the z coordinate of this residue's CA Methods inherited from SecstructSRFD: apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.SecstructSRFD,  : str, seq_pos : int) -> bool secstruct(...) from builtins.PyCapsule secstruct(rosetta.core.fragment.SecstructSRFD) -> str   get secstruct for this position set_secstruct(...) from builtins.PyCapsule set_secstruct(self : rosetta.core.fragment.SecstructSRFD, ss : str) -> NoneType Methods inherited from SingleResidueFragData: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.SingleResidueFragData) -> str sequence(...) from builtins.PyCapsule sequence(rosetta.core.fragment.SingleResidueFragData) -> str set_sequence(...) from builtins.PyCapsule set_sequence(self : rosetta.core.fragment.SingleResidueFragData, sequence : str) -> NoneType   class BaseCacheUnit(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.fragment.BaseCacheUnit) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.BaseCacheUnit,  : rosetta.core.fragment.BaseCacheUnit) -> rosetta.core.fragment.BaseCacheUnit clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.BaseCacheUnit) -> rosetta.core.fragment.BaseCacheUnit remap_value(...) from builtins.PyCapsule remap_value(self : rosetta.core.fragment.BaseCacheUnit, source : rosetta.core.fragment.BaseCacheUnit, source_id : int, new_id : int) -> NoneType   class ConstFrameIterator(rosetta.std.iterator_std_forward_iterator_tag_core_fragment_Frame_long_core_fragment_Frame_*_core_fragment_Frame_&_t)       Method resolution order: ConstFrameIterator rosetta.std.iterator_std_forward_iterator_tag_core_fragment_Frame_long_core_fragment_Frame_*_core_fragment_Frame_&_t builtins.object Methods defined here: __add__(...) from builtins.PyCapsule __add__(self : rosetta.core.fragment.ConstFrameIterator, offset : int) -> rosetta.core.fragment.ConstFrameIterator __eq__(...) from builtins.PyCapsule __eq__(self : rosetta.core.fragment.ConstFrameIterator, fi : rosetta.core.fragment.ConstFrameIterator) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.fragment.ConstFrameIterator, it : rosetta.core.fragment.FrameIteratorWorker_) -> NoneType   2. __init__(rosetta.core.fragment.ConstFrameIterator) -> NoneType   3. __init__(self : rosetta.core.fragment.ConstFrameIterator,  : rosetta.core.fragment.ConstFrameIterator) -> NoneType __ne__(...) from builtins.PyCapsule __ne__(self : rosetta.core.fragment.ConstFrameIterator, fi : rosetta.core.fragment.ConstFrameIterator) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.ConstFrameIterator, itr : rosetta.core.fragment.ConstFrameIterator) -> rosetta.core.fragment.ConstFrameIterator frame_ptr(...) from builtins.PyCapsule frame_ptr(rosetta.core.fragment.ConstFrameIterator) -> rosetta.core.fragment.Frame plus_plus(...) from builtins.PyCapsule plus_plus(rosetta.core.fragment.ConstFrameIterator) -> rosetta.core.fragment.ConstFrameIterator   class ConstantLengthFragSet(FragSet)     A set of fragments that contains fragments of a constant length read in from a fragment file.     this object is a simple implementation of the FragSet     for custom fragments, check out https://robetta.bakerlab.org/fragmentsubmit.jsp   example:     ninemers = ConstantLengthFragSet(9)     ninemers.read_fragment_file("test9_fragments") See also:     Pose     ClassicFragmentMover     Method resolution order: ConstantLengthFragSet FragSet builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, frag_length : int) -> NoneType   2. __init__(self : handle, frag_length : int, filename : str) -> NoneType   3. __init__(handle) -> NoneType   4. __init__(self : handle, fragments : rosetta.core.fragment.FragSet) -> NoneType   5. __init__(handle, rosetta.core.fragment.ConstantLengthFragSet) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.ConstantLengthFragSet,  : rosetta.core.fragment.ConstantLengthFragSet) -> rosetta.core.fragment.ConstantLengthFragSet begin(...) from builtins.PyCapsule begin(rosetta.core.fragment.ConstantLengthFragSet) -> core::fragment::ConstFrameIterator   iterate over contents clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.ConstantLengthFragSet) -> rosetta.core.fragment.FragSet empty(...) from builtins.PyCapsule empty(rosetta.core.fragment.ConstantLengthFragSet) -> bool empty_clone(...) from builtins.PyCapsule empty_clone(rosetta.core.fragment.ConstantLengthFragSet) -> rosetta.core.fragment.FragSet end(...) from builtins.PyCapsule end(rosetta.core.fragment.ConstantLengthFragSet) -> core::fragment::ConstFrameIterator nonconst_begin(...) from builtins.PyCapsule nonconst_begin(rosetta.core.fragment.ConstantLengthFragSet) -> core::fragment::FrameIterator nonconst_end(...) from builtins.PyCapsule nonconst_end(rosetta.core.fragment.ConstantLengthFragSet) -> core::fragment::FrameIterator overlapping_with_region(...) from builtins.PyCapsule overlapping_with_region(self : rosetta.core.fragment.ConstantLengthFragSet, mm : core::kinematics::MoveMap, start : int, end : int, min_overlap : int, min_length : int, frames : rosetta.core.fragment.FrameList) -> int   returns the number and list of all fragment alignment frames that somehow overlap with the given region (also allows those frames that start before the region and reach into it) read_fragment_file(...) from builtins.PyCapsule read_fragment_file(*args, **kwargs) Overloaded function.   1. read_fragment_file(self : rosetta.core.fragment.ConstantLengthFragSet, filename : str) -> NoneType   Loads the contents of  <filename>  into the ConstantLengthFragSet    example:      ninemers.read_fragment_file("test9_fragments")  See also:      ConstantLengthFragSet      Pose      Pose.omega      Pose.phi      Pose.psi      ClassicFragmentMover   2. read_fragment_file(self : rosetta.core.fragment.ConstantLengthFragSet, filename : str, top25 : int) -> NoneType   Loads the contents of  <filename>  into the ConstantLengthFragSet    example:      ninemers.read_fragment_file("test9_fragments")  See also:      ConstantLengthFragSet      Pose      Pose.omega      Pose.phi      Pose.psi      ClassicFragmentMover   3. read_fragment_file(self : rosetta.core.fragment.ConstantLengthFragSet, filename : str, top25 : int, ncopies : int) -> NoneType   Loads the contents of  <filename>  into the ConstantLengthFragSet    example:      ninemers.read_fragment_file("test9_fragments")  See also:      ConstantLengthFragSet      Pose      Pose.omega      Pose.phi      Pose.psi      ClassicFragmentMover   4. read_fragment_file(self : rosetta.core.fragment.ConstantLengthFragSet, filename : str, top25 : int, ncopies : int, bAnnotation : bool) -> NoneType   Loads the contents of  <filename>  into the ConstantLengthFragSet    example:      ninemers.read_fragment_file("test9_fragments")  See also:      ConstantLengthFragSet      Pose      Pose.omega      Pose.phi      Pose.psi      ClassicFragmentMover read_fragment_stream(...) from builtins.PyCapsule read_fragment_stream(*args, **kwargs) Overloaded function.   1. read_fragment_stream(self : rosetta.core.fragment.ConstantLengthFragSet, data : rosetta.utility.io.izstream) -> NoneType   2. read_fragment_stream(self : rosetta.core.fragment.ConstantLengthFragSet, data : rosetta.utility.io.izstream, top25 : int) -> NoneType   3. read_fragment_stream(self : rosetta.core.fragment.ConstantLengthFragSet, data : rosetta.utility.io.izstream, top25 : int, ncopies : int) -> NoneType   4. read_fragment_stream(self : rosetta.core.fragment.ConstantLengthFragSet, data : rosetta.utility.io.izstream, top25 : int, ncopies : int, bAnnotation : bool) -> NoneType region(...) from builtins.PyCapsule region(self : rosetta.core.fragment.ConstantLengthFragSet, mm : core::kinematics::MoveMap, start : int, end : int,  : int,  : int, frames : rosetta.core.fragment.FrameList) -> int   there is only one Frame per position, end / max_overlap are ignored Methods inherited from FragSet: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.FragSet) -> str add(...) from builtins.PyCapsule add(*args, **kwargs) Overloaded function.   1. add(self : rosetta.core.fragment.FragSet, aFrame : core::fragment::Frame) -> NoneType   add a single frame. if compatible frame is already in set the frames will be merged   2. add(self : rosetta.core.fragment.FragSet, frames : core::fragment::FrameList) -> NoneType   add all Frames in list   3. add(self : rosetta.core.fragment.FragSet, frames : rosetta.core.fragment.FragSet) -> NoneType   add all Frames in FragSet   4. add(self : rosetta.core.fragment.FragSet,  : core::fragment::FragID) -> NoneType   add single fragment clone_shifted(...) from builtins.PyCapsule clone_shifted(self : rosetta.core.fragment.FragSet,  : int) -> rosetta.core.fragment.FragSet frames(...) from builtins.PyCapsule frames(self : rosetta.core.fragment.FragSet, pos : int, frames : core::fragment::FrameList) -> int   appends frames at sequence position pos to frames, returns nr of frames added generate_insert_map(...) from builtins.PyCapsule generate_insert_map(self : rosetta.core.fragment.FragSet, mm : core::kinematics::MoveMap, insert_map : rosetta.utility.vector1_unsigned_long, insert_size : rosetta.utility.vector1_unsigned_long) -> NoneType   InsertMap and InsertSize gives quick overview which residues can be affected by fragments.  insert_map --- list of start-positions, insert_size corresponding list of longest fragment at position x global_offset(...) from builtins.PyCapsule global_offset(*args, **kwargs) Overloaded function.   1. global_offset(rosetta.core.fragment.FragSet) -> int   2. global_offset(self : rosetta.core.fragment.FragSet,  : int) -> NoneType   resets global_offset of FragSet and shifts FragSet if necessary by calling shift_to max_frag_length(...) from builtins.PyCapsule max_frag_length(rosetta.core.fragment.FragSet) -> int   returns the longest fragment stored in this FragSet. max_pos(...) from builtins.PyCapsule max_pos(rosetta.core.fragment.FragSet) -> int   returns the maximal sequence position that can be affected by fragments in this set min_pos(...) from builtins.PyCapsule min_pos(rosetta.core.fragment.FragSet) -> int   returns the first sequence position that can be affected by fragments in this set nr_frames(...) from builtins.PyCapsule nr_frames(rosetta.core.fragment.FragSet) -> int   counts number of frames ( slow! - it really counts ) region_all(...) from builtins.PyCapsule region_all(self : rosetta.core.fragment.FragSet, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   return a list of frames that all sample the specified region, assume all motions are allowed region_simple(...) from builtins.PyCapsule region_simple(self : rosetta.core.fragment.FragSet, start : int, end : int, frames : core::fragment::FrameList) -> int   returns fragments that exactly span seq_pos start...end shift_by(...) from builtins.PyCapsule shift_by(self : rosetta.core.fragment.FragSet, offset : int) -> NoneType   shift all frames in FragSet by offset size(...) from builtins.PyCapsule size(rosetta.core.fragment.FragSet) -> int   returns total size--> counts together all frags in each frame   class ConstantLengthFragSetIterator_(FrameIteratorWorker_)       Method resolution order: ConstantLengthFragSetIterator_ FrameIteratorWorker_ builtins.object Methods defined here: __init__(self, /, *args, **kwargs) Initialize self.  See help(type(self)) for accurate signature. __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature.   class DownJumpSRFD(SingleResidueFragData)       Method resolution order: DownJumpSRFD SingleResidueFragData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   doc   2. __init__(self : handle, sequence : str) -> NoneType   3. __init__(self : handle, rt : rosetta.core.kinematics.RT, downstream_stub_atoms : rosetta.utility.vector1_std_string, upstream_stub_atoms : rosetta.utility.vector1_std_string, sequence : str) -> NoneType   4. __init__(handle, rosetta.core.fragment.DownJumpSRFD) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.DownJumpSRFD,  : core::pose::Pose, intra_frame_pos : int,  : rosetta.core.fragment.Frame) -> bool   the seq_pos is hijacked for the rt_nr   2. apply(self : rosetta.core.fragment.DownJumpSRFD,  : core::kinematics::MoveMap,  : core::pose::Pose, intra_frame_pos : int,  : rosetta.core.fragment.Frame) -> bool   3. apply(self : rosetta.core.fragment.DownJumpSRFD,  : core::pose::Pose,  : int) -> bool   4. apply(self : rosetta.core.fragment.DownJumpSRFD,  : core::kinematics::MoveMap,  : core::pose::Pose,  : int) -> bool   for DownJumpSRFD this function should never be called, instead use Frame version      always false      will trigger a false runtime assert apply_ss(...) from builtins.PyCapsule apply_ss(*args, **kwargs) Overloaded function.   1. apply_ss(self : rosetta.core.fragment.DownJumpSRFD,  : str,  : int,  : rosetta.core.fragment.Frame) -> bool   2. apply_ss(self : rosetta.core.fragment.DownJumpSRFD,  : str,  : int) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.DownJumpSRFD,  : rosetta.core.fragment.DownJumpSRFD) -> rosetta.core.fragment.DownJumpSRFD clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.DownJumpSRFD) -> rosetta.core.fragment.SingleResidueFragData   clone create(...) from builtins.PyCapsule create(rosetta.core.fragment.DownJumpSRFD) -> rosetta.core.fragment.SingleResidueFragData   create a new instance of this object is_applicable(...) from builtins.PyCapsule is_applicable(*args, **kwargs) Overloaded function.   1. is_applicable(self : rosetta.core.fragment.DownJumpSRFD,  : core::kinematics::MoveMap, pos : int,  : rosetta.core.fragment.Frame) -> bool   2. is_applicable(self : rosetta.core.fragment.DownJumpSRFD,  : core::kinematics::MoveMap,  : int) -> bool is_compatible(...) from builtins.PyCapsule is_compatible(self : rosetta.core.fragment.DownJumpSRFD,  : rosetta.core.fragment.SingleResidueFragData) -> bool set_jump(...) from builtins.PyCapsule set_jump(self : rosetta.core.fragment.DownJumpSRFD, setting : rosetta.core.kinematics.RT) -> NoneType   set value of jump set_standard_stub_atoms(...) from builtins.PyCapsule set_standard_stub_atoms(rosetta.core.fragment.DownJumpSRFD) -> NoneType set_stub_atoms(...) from builtins.PyCapsule set_stub_atoms(self : rosetta.core.fragment.DownJumpSRFD, downstream : rosetta.utility.vector1_std_string, upstream : rosetta.utility.vector1_std_string) -> NoneType steal(...) from builtins.PyCapsule steal(*args, **kwargs) Overloaded function.   1. steal(self : rosetta.core.fragment.DownJumpSRFD,  : core::pose::Pose, pos : int,  : rosetta.core.fragment.Frame) -> bool   2. steal(self : rosetta.core.fragment.DownJumpSRFD,  : core::pose::Pose,  : int) -> bool type(...) from builtins.PyCapsule type(rosetta.core.fragment.DownJumpSRFD) -> str Methods inherited from SingleResidueFragData: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.SingleResidueFragData) -> str secstruct(...) from builtins.PyCapsule secstruct(rosetta.core.fragment.SingleResidueFragData) -> str sequence(...) from builtins.PyCapsule sequence(rosetta.core.fragment.SingleResidueFragData) -> str set_sequence(...) from builtins.PyCapsule set_sequence(self : rosetta.core.fragment.SingleResidueFragData, sequence : str) -> NoneType   class FragData(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle,  : rosetta.core.fragment.SingleResidueFragData, n : int) -> NoneType   3. __init__(handle, rosetta.core.fragment.FragData) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.FragData) -> str add_residue(...) from builtins.PyCapsule add_residue(self : rosetta.core.fragment.FragData, res : rosetta.core.fragment.SingleResidueFragData) -> NoneType apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap,  : core::pose::Pose, start : int, end : int) -> int   2. apply(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap,  : core::pose::Pose,  : rosetta.core.fragment.Frame) -> int   3. apply(self : rosetta.core.fragment.FragData,  : core::pose::Pose,  : rosetta.core.fragment.Frame) -> int   4. apply(self : rosetta.core.fragment.FragData,  : core::pose::Pose, start : int, end : int) -> int apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap, ss : str,  : rosetta.core.fragment.Frame) -> int assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.FragData,  : rosetta.core.fragment.FragData) -> rosetta.core.fragment.FragData chain(...) from builtins.PyCapsule chain(rosetta.core.fragment.FragData) -> str   Returns the chain if it has been specified, '_' otherwise. clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.FragData) -> rosetta.core.fragment.FragData copy(...) from builtins.PyCapsule copy(self : rosetta.core.fragment.FragData, frag_data : rosetta.core.fragment.FragData) -> NoneType generate_sub_fragment(...) from builtins.PyCapsule generate_sub_fragment(self : rosetta.core.fragment.FragData, start : int, stop : int) -> rosetta.core.fragment.FragData get_residue(...) from builtins.PyCapsule get_residue(self : rosetta.core.fragment.FragData, pos : int) -> rosetta.core.fragment.SingleResidueFragData get_self_ptr(...) from builtins.PyCapsule get_self_ptr(*args, **kwargs) Overloaded function.   1. get_self_ptr(rosetta.core.fragment.FragData) -> rosetta.core.fragment.FragData   self pointers   2. get_self_ptr(rosetta.core.fragment.FragData) -> rosetta.core.fragment.FragData is_applicable(...) from builtins.PyCapsule is_applicable(*args, **kwargs) Overloaded function.   1. is_applicable(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap, start : int, end : int) -> int   2. is_applicable(self : rosetta.core.fragment.FragData,  : core::kinematics::MoveMap,  : rosetta.core.fragment.Frame) -> int is_compatible(...) from builtins.PyCapsule is_compatible(self : rosetta.core.fragment.FragData, frag_data : rosetta.core.fragment.FragData) -> bool is_valid(...) from builtins.PyCapsule is_valid(rosetta.core.fragment.FragData) -> bool pdbid(...) from builtins.PyCapsule pdbid(rosetta.core.fragment.FragData) -> str   Returns the PDB identifier if it has been specified, "no_pdb" otherwise. pdbpos(...) from builtins.PyCapsule pdbpos(rosetta.core.fragment.FragData) -> int score(...) from builtins.PyCapsule score(rosetta.core.fragment.FragData) -> float   Returns the score for this fragment secstruct(...) from builtins.PyCapsule secstruct(*args, **kwargs) Overloaded function.   1. secstruct(self : rosetta.core.fragment.FragData, pos : int) -> str   2. secstruct(rosetta.core.fragment.FragData) -> str sequence(...) from builtins.PyCapsule sequence(*args, **kwargs) Overloaded function.   1. sequence(self : rosetta.core.fragment.FragData, pos : int) -> str   2. sequence(rosetta.core.fragment.FragData) -> str set_residue(...) from builtins.PyCapsule set_residue(self : rosetta.core.fragment.FragData, pos : int, res : rosetta.core.fragment.SingleResidueFragData) -> NoneType set_score(...) from builtins.PyCapsule set_score(self : rosetta.core.fragment.FragData, score : float) -> NoneType   Set a score value for this fragment set_sequence(...) from builtins.PyCapsule set_sequence(self : rosetta.core.fragment.FragData, pos : int, setting : str) -> NoneType set_valid(...) from builtins.PyCapsule set_valid(*args, **kwargs) Overloaded function.   1. set_valid(rosetta.core.fragment.FragData) -> NoneType   2. set_valid(self : rosetta.core.fragment.FragData, setting : bool) -> NoneType size(...) from builtins.PyCapsule size(rosetta.core.fragment.FragData) -> int steal(...) from builtins.PyCapsule steal(*args, **kwargs) Overloaded function.   1. steal(self : rosetta.core.fragment.FragData,  : core::pose::Pose, start : int, end : int) -> bool   2. steal(self : rosetta.core.fragment.FragData,  : core::pose::Pose,  : rosetta.core.fragment.Frame) -> bool   class FragFactory(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.fragment.FragFactory) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_frag_type(...) from builtins.PyCapsule add_frag_type(self : rosetta.core.fragment.FragFactory, type_name : str, frag_type : rosetta.core.fragment.SingleResidueFragData) -> NoneType add_frame_type(...) from builtins.PyCapsule add_frame_type(self : rosetta.core.fragment.FragFactory, type_name : str, new_frag : rosetta.core.fragment.Frame) -> NoneType frag_type(...) from builtins.PyCapsule frag_type(self : rosetta.core.fragment.FragFactory, frag_name : str) -> rosetta.core.fragment.SingleResidueFragData frame(...) from builtins.PyCapsule frame(self : rosetta.core.fragment.FragFactory, frame_name : str) -> rosetta.core.fragment.Frame   class FragID(builtins.object)       Methods defined here: __eq__(...) from builtins.PyCapsule __eq__(self : rosetta.core.fragment.FragID, other : rosetta.core.fragment.FragID) -> bool   Equality operator (previously free when FragID derived from std::pair). __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.fragment.FragID) -> NoneType   2. __init__(self : rosetta.core.fragment.FragID, frame : rosetta.core.fragment.Frame, frag_id : int) -> NoneType   3. __init__(self : rosetta.core.fragment.FragID,  : rosetta.core.fragment.FragID) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.FragID, mm : core::kinematics::MoveMap, pose : core::pose::Pose) -> int   2. apply(self : rosetta.core.fragment.FragID, pose : core::pose::Pose) -> int apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.FragID, mm : core::kinematics::MoveMap, ss : str) -> int assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.FragID, rhs : rosetta.core.fragment.FragID) -> rosetta.core.fragment.FragID fragment(...) from builtins.PyCapsule fragment(rosetta.core.fragment.FragID) -> core::fragment::FragData fragment_ptr(...) from builtins.PyCapsule fragment_ptr(rosetta.core.fragment.FragID) -> core::fragment::FragData frame(...) from builtins.PyCapsule frame(rosetta.core.fragment.FragID) -> rosetta.core.fragment.Frame frame_ptr(...) from builtins.PyCapsule frame_ptr(rosetta.core.fragment.FragID) -> rosetta.core.fragment.Frame id(...) from builtins.PyCapsule id(rosetta.core.fragment.FragID) -> int is_valid(...) from builtins.PyCapsule is_valid(rosetta.core.fragment.FragID) -> bool Data descriptors defined here: first second   class FragID_Iterator(builtins.object)       Methods defined here: __add__(...) from builtins.PyCapsule __add__(self : rosetta.core.fragment.FragID_Iterator, offset : int) -> rosetta.core.fragment.FragID_Iterator __eq__(...) from builtins.PyCapsule __eq__(self : rosetta.core.fragment.FragID_Iterator, fi : rosetta.core.fragment.FragID_Iterator) -> bool __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.fragment.FragID_Iterator, it : core::fragment::ConstFrameIterator) -> NoneType   2. __init__(self : rosetta.core.fragment.FragID_Iterator, it : core::fragment::FrameIterator) -> NoneType   3. __init__(self : rosetta.core.fragment.FragID_Iterator, it : rosetta.core.fragment.FrameIteratorWorker_) -> NoneType   4. __init__(self : rosetta.core.fragment.FragID_Iterator, it : __gnu_cxx::__normal_iterator<std::shared_ptr<core::fragment::Frame>*, std::vector<std::shared_ptr<core::fragment::Frame>, std::allocator<std::shared_ptr<core::fragment::Frame> > > >) -> NoneType   5. __init__(rosetta.core.fragment.FragID_Iterator) -> NoneType   6. __init__(self : rosetta.core.fragment.FragID_Iterator,  : rosetta.core.fragment.FragID_Iterator) -> NoneType __ne__(...) from builtins.PyCapsule __ne__(self : rosetta.core.fragment.FragID_Iterator, fi : rosetta.core.fragment.FragID_Iterator) -> bool __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.FragID_Iterator, itr : rosetta.core.fragment.FragID_Iterator) -> rosetta.core.fragment.FragID_Iterator frag_id(...) from builtins.PyCapsule frag_id(rosetta.core.fragment.FragID_Iterator) -> rosetta.core.fragment.FragID plus_plus(...) from builtins.PyCapsule plus_plus(rosetta.core.fragment.FragID_Iterator) -> rosetta.core.fragment.FragID_Iterator   class FragSet(builtins.object)     The FragSet: (Interface Definition -- Virtual BaseClass )     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.fragment.FragSet) -> NoneType   2. __init__(rosetta.core.fragment.FragSet, rosetta.core.fragment.FragSet) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.FragSet) -> str add(...) from builtins.PyCapsule add(*args, **kwargs) Overloaded function.   1. add(self : rosetta.core.fragment.FragSet, aFrame : core::fragment::Frame) -> NoneType   add a single frame. if compatible frame is already in set the frames will be merged   2. add(self : rosetta.core.fragment.FragSet, frames : core::fragment::FrameList) -> NoneType   add all Frames in list   3. add(self : rosetta.core.fragment.FragSet, frames : rosetta.core.fragment.FragSet) -> NoneType   add all Frames in FragSet   4. add(self : rosetta.core.fragment.FragSet,  : core::fragment::FragID) -> NoneType   add single fragment assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.FragSet,  : rosetta.core.fragment.FragSet) -> rosetta.core.fragment.FragSet begin(...) from builtins.PyCapsule begin(rosetta.core.fragment.FragSet) -> core::fragment::ConstFrameIterator   iterate over contents clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.FragSet) -> rosetta.core.fragment.FragSet   clone and copy the pointer of all Frames (Frames will not be copied) clone_shifted(...) from builtins.PyCapsule clone_shifted(self : rosetta.core.fragment.FragSet,  : int) -> rosetta.core.fragment.FragSet empty(...) from builtins.PyCapsule empty(rosetta.core.fragment.FragSet) -> bool empty_clone(...) from builtins.PyCapsule empty_clone(rosetta.core.fragment.FragSet) -> rosetta.core.fragment.FragSet   create an empty clone end(...) from builtins.PyCapsule end(rosetta.core.fragment.FragSet) -> core::fragment::ConstFrameIterator frames(...) from builtins.PyCapsule frames(self : rosetta.core.fragment.FragSet, pos : int, frames : core::fragment::FrameList) -> int   appends frames at sequence position pos to frames, returns nr of frames added generate_insert_map(...) from builtins.PyCapsule generate_insert_map(self : rosetta.core.fragment.FragSet, mm : core::kinematics::MoveMap, insert_map : rosetta.utility.vector1_unsigned_long, insert_size : rosetta.utility.vector1_unsigned_long) -> NoneType   InsertMap and InsertSize gives quick overview which residues can be affected by fragments.  insert_map --- list of start-positions, insert_size corresponding list of longest fragment at position x global_offset(...) from builtins.PyCapsule global_offset(*args, **kwargs) Overloaded function.   1. global_offset(rosetta.core.fragment.FragSet) -> int   2. global_offset(self : rosetta.core.fragment.FragSet,  : int) -> NoneType   resets global_offset of FragSet and shifts FragSet if necessary by calling shift_to max_frag_length(...) from builtins.PyCapsule max_frag_length(rosetta.core.fragment.FragSet) -> int   returns the longest fragment stored in this FragSet. max_pos(...) from builtins.PyCapsule max_pos(rosetta.core.fragment.FragSet) -> int   returns the maximal sequence position that can be affected by fragments in this set min_pos(...) from builtins.PyCapsule min_pos(rosetta.core.fragment.FragSet) -> int   returns the first sequence position that can be affected by fragments in this set nonconst_begin(...) from builtins.PyCapsule nonconst_begin(rosetta.core.fragment.FragSet) -> core::fragment::FrameIterator   iterate over contents nonconst_end(...) from builtins.PyCapsule nonconst_end(rosetta.core.fragment.FragSet) -> core::fragment::FrameIterator nr_frames(...) from builtins.PyCapsule nr_frames(rosetta.core.fragment.FragSet) -> int   counts number of frames ( slow! - it really counts ) overlapping_with_region(...) from builtins.PyCapsule overlapping_with_region(self : rosetta.core.fragment.FragSet, mm : core::kinematics::MoveMap, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   returns the number and list of all fragment alignment frames that somehow overlap with the given region (also allows those frames that start before the region and reach into it) region(...) from builtins.PyCapsule region(self : rosetta.core.fragment.FragSet, move_map : core::kinematics::MoveMap, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   the region thing has to be thought-over. How do we really want to sample fragments?  for now, we ignore everything in this call and just return frags that have "start" as there specified start() entry. region_all(...) from builtins.PyCapsule region_all(self : rosetta.core.fragment.FragSet, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   return a list of frames that all sample the specified region, assume all motions are allowed region_simple(...) from builtins.PyCapsule region_simple(self : rosetta.core.fragment.FragSet, start : int, end : int, frames : core::fragment::FrameList) -> int   returns fragments that exactly span seq_pos start...end shift_by(...) from builtins.PyCapsule shift_by(self : rosetta.core.fragment.FragSet, offset : int) -> NoneType   shift all frames in FragSet by offset size(...) from builtins.PyCapsule size(rosetta.core.fragment.FragSet) -> int   returns total size--> counts together all frags in each frame   class FragSetCollection(FragSet)       Method resolution order: FragSetCollection FragSet builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(handle, rosetta.core.fragment.FragSetCollection) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. add_fragset(...) from builtins.PyCapsule add_fragset(self : rosetta.core.fragment.FragSetCollection, fragset : rosetta.core.fragment.FragSet) -> NoneType assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.FragSetCollection,  : rosetta.core.fragment.FragSetCollection) -> rosetta.core.fragment.FragSetCollection begin(...) from builtins.PyCapsule begin(rosetta.core.fragment.FragSetCollection) -> core::fragment::ConstFrameIterator clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.FragSetCollection) -> rosetta.core.fragment.FragSet empty(...) from builtins.PyCapsule empty(rosetta.core.fragment.FragSetCollection) -> bool empty_clone(...) from builtins.PyCapsule empty_clone(rosetta.core.fragment.FragSetCollection) -> rosetta.core.fragment.FragSet end(...) from builtins.PyCapsule end(rosetta.core.fragment.FragSetCollection) -> core::fragment::ConstFrameIterator nonconst_begin(...) from builtins.PyCapsule nonconst_begin(rosetta.core.fragment.FragSetCollection) -> core::fragment::FrameIterator nonconst_end(...) from builtins.PyCapsule nonconst_end(rosetta.core.fragment.FragSetCollection) -> core::fragment::FrameIterator region(...) from builtins.PyCapsule region(self : rosetta.core.fragment.FragSetCollection, move_map : core::kinematics::MoveMap, start : int, end : int, min_overlap : int, min_length : int, frames : rosetta.core.fragment.FrameList) -> int Methods inherited from FragSet: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.FragSet) -> str add(...) from builtins.PyCapsule add(*args, **kwargs) Overloaded function.   1. add(self : rosetta.core.fragment.FragSet, aFrame : core::fragment::Frame) -> NoneType   add a single frame. if compatible frame is already in set the frames will be merged   2. add(self : rosetta.core.fragment.FragSet, frames : core::fragment::FrameList) -> NoneType   add all Frames in list   3. add(self : rosetta.core.fragment.FragSet, frames : rosetta.core.fragment.FragSet) -> NoneType   add all Frames in FragSet   4. add(self : rosetta.core.fragment.FragSet,  : core::fragment::FragID) -> NoneType   add single fragment clone_shifted(...) from builtins.PyCapsule clone_shifted(self : rosetta.core.fragment.FragSet,  : int) -> rosetta.core.fragment.FragSet frames(...) from builtins.PyCapsule frames(self : rosetta.core.fragment.FragSet, pos : int, frames : core::fragment::FrameList) -> int   appends frames at sequence position pos to frames, returns nr of frames added generate_insert_map(...) from builtins.PyCapsule generate_insert_map(self : rosetta.core.fragment.FragSet, mm : core::kinematics::MoveMap, insert_map : rosetta.utility.vector1_unsigned_long, insert_size : rosetta.utility.vector1_unsigned_long) -> NoneType   InsertMap and InsertSize gives quick overview which residues can be affected by fragments.  insert_map --- list of start-positions, insert_size corresponding list of longest fragment at position x global_offset(...) from builtins.PyCapsule global_offset(*args, **kwargs) Overloaded function.   1. global_offset(rosetta.core.fragment.FragSet) -> int   2. global_offset(self : rosetta.core.fragment.FragSet,  : int) -> NoneType   resets global_offset of FragSet and shifts FragSet if necessary by calling shift_to max_frag_length(...) from builtins.PyCapsule max_frag_length(rosetta.core.fragment.FragSet) -> int   returns the longest fragment stored in this FragSet. max_pos(...) from builtins.PyCapsule max_pos(rosetta.core.fragment.FragSet) -> int   returns the maximal sequence position that can be affected by fragments in this set min_pos(...) from builtins.PyCapsule min_pos(rosetta.core.fragment.FragSet) -> int   returns the first sequence position that can be affected by fragments in this set nr_frames(...) from builtins.PyCapsule nr_frames(rosetta.core.fragment.FragSet) -> int   counts number of frames ( slow! - it really counts ) overlapping_with_region(...) from builtins.PyCapsule overlapping_with_region(self : rosetta.core.fragment.FragSet, mm : core::kinematics::MoveMap, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   returns the number and list of all fragment alignment frames that somehow overlap with the given region (also allows those frames that start before the region and reach into it) region_all(...) from builtins.PyCapsule region_all(self : rosetta.core.fragment.FragSet, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   return a list of frames that all sample the specified region, assume all motions are allowed region_simple(...) from builtins.PyCapsule region_simple(self : rosetta.core.fragment.FragSet, start : int, end : int, frames : core::fragment::FrameList) -> int   returns fragments that exactly span seq_pos start...end shift_by(...) from builtins.PyCapsule shift_by(self : rosetta.core.fragment.FragSet, offset : int) -> NoneType   shift all frames in FragSet by offset size(...) from builtins.PyCapsule size(rosetta.core.fragment.FragSet) -> int   returns total size--> counts together all frags in each frame   class FragmentIO(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.fragment.FragmentIO) -> NoneType   2. __init__(rosetta.core.fragment.FragmentIO, int) -> NoneType   doc   3. __init__(rosetta.core.fragment.FragmentIO, int, int) -> NoneType   doc   4. __init__(self : rosetta.core.fragment.FragmentIO, top : int, ncopies : int, bAnnotate : bool) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. clean_frag_cache(...) from builtins.PyCapsule clean_frag_cache(rosetta.core.fragment.FragmentIO) -> NoneType   remove all FragSets that are not referenced outside the cache. get_frag_factory(...) from builtins.PyCapsule get_frag_factory(rosetta.core.fragment.FragmentIO) -> rosetta.core.fragment.FragFactory read_data(...) from builtins.PyCapsule read_data(*args, **kwargs) Overloaded function.   1. read_data(self : rosetta.core.fragment.FragmentIO, filename : str) -> rosetta.core.fragment.FragSet   read a FragSet... note that this function caches the fragment set.  i.e., if you read the same set from multiple positions in the code you get  the same set. if you read a new file ... we'll check the cache for stale  references and delete them...   2. read_data(self : rosetta.core.fragment.FragmentIO, filename : str,  : rosetta.core.fragment.FrameList) -> NoneType set_ncopies(...) from builtins.PyCapsule set_ncopies(self : rosetta.core.fragment.FragmentIO, setting : int) -> NoneType   Updates the number of copies of each fragment to keep (default 1) set_read_annotation(...) from builtins.PyCapsule set_read_annotation(*args, **kwargs) Overloaded function.   1. set_read_annotation(rosetta.core.fragment.FragmentIO) -> NoneType   Toggles between reading annotated (true) and non-annotated (false)   2. set_read_annotation(self : rosetta.core.fragment.FragmentIO, setting : bool) -> NoneType   Toggles between reading annotated (true) and non-annotated (false) set_top_frag_num(...) from builtins.PyCapsule set_top_frag_num(self : rosetta.core.fragment.FragmentIO, setting : int) -> NoneType   Updates the number of distinct fragments to keep write_data(...) from builtins.PyCapsule write_data(self : rosetta.core.fragment.FragmentIO, file : str, frags : rosetta.core.fragment.FragSet) -> NoneType   class FragmentRmsd(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.fragment.FragmentRmsd, fragments : rosetta.core.fragment.FragSet) -> NoneType   2. __init__(self : rosetta.core.fragment.FragmentRmsd,  : rosetta.core.fragment.FragmentRmsd) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.FragmentRmsd,  : rosetta.core.fragment.FragmentRmsd) -> rosetta.core.fragment.FragmentRmsd fragment(...) from builtins.PyCapsule fragment(self : rosetta.core.fragment.FragmentRmsd, position : int, k : int) -> rosetta.core.fragment.FragData   Returns the kth fragment at the specified position  in the fragment library. rmsd(...) from builtins.PyCapsule rmsd(self : rosetta.core.fragment.FragmentRmsd, position : int, k : int, reference : core::pose::Pose) -> float   Returns the RMSD of the kth fragment at the specified position  in the fragment library and pose.   class Frame(builtins.object)     Frame couples a list of FragData-instances to a certain alignment frame, i.e., position in sequence space     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.     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, begin : int, end : int, nr_res : int) -> NoneType   3. __init__(self : handle, start : int, length : int) -> NoneType   4. __init__(self : handle, start : int) -> NoneType   5. __init__(self : handle, start : int, frag1 : core::fragment::FragData) -> NoneType   6. __init__(self : handle, start : int, length : int, srfd : rosetta.core.fragment.SingleResidueFragData) -> NoneType   7. __init__(handle, rosetta.core.fragment.Frame) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.Frame) -> str add_fragment(...) from builtins.PyCapsule add_fragment(*args, **kwargs) Overloaded function.   1. add_fragment(self : rosetta.core.fragment.Frame, new_frag : core::fragment::FragData) -> int   add a fragment .. return new frag_nr   2. add_fragment(self : rosetta.core.fragment.Frame, new_frags : rosetta.utility.vector1_std_shared_ptr_const_core_fragment_FragData_t) -> bool   add all fragments in list align(...) from builtins.PyCapsule align(self : rosetta.core.fragment.Frame, map : rosetta.core.id.SequenceMapping) -> bool   change frames residue numbers accoriding to map apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.Frame,  : core::kinematics::MoveMap, frag_num : int, pose : core::pose::Pose) -> int   insert fragment frag_num into pose   2. apply(self : rosetta.core.fragment.Frame, frag_num : int, pose : core::pose::Pose) -> int   insert fragment frag_num into pose --- ignore movemap apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.Frame,  : core::kinematics::MoveMap, frag_num : int, ss : str) -> int   change ss-string according to sec-struct info in fragments assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.Frame,  : rosetta.core.fragment.Frame) -> rosetta.core.fragment.Frame cache(...) from builtins.PyCapsule cache(self : rosetta.core.fragment.Frame, tag : str, new_cache : rosetta.core.fragment.BaseCacheUnit) -> rosetta.core.fragment.BaseCacheUnit   return handle to cached data stored under "tag"  shouldn't be called directly clear(...) from builtins.PyCapsule clear(rosetta.core.fragment.Frame) -> NoneType   remove all valid fragments, a template fragment will be left over clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.Frame) -> rosetta.core.fragment.Frame   clone method, new frame with same alignment position, fragments are not copied! clone_cache_data(...) from builtins.PyCapsule clone_cache_data(self : rosetta.core.fragment.Frame, source : rosetta.core.fragment.Frame, sid : int, nid : int) -> NoneType   copies all entries in the Frame-Cache for fragment "sid" of Frame "source" to fragment "nid" of "this" frame clone_with_frags(...) from builtins.PyCapsule clone_with_frags(rosetta.core.fragment.Frame) -> rosetta.core.fragment.Frame   clone method, new frame with same alignment position, fragments are not copied! clone_with_template(...) from builtins.PyCapsule clone_with_template(rosetta.core.fragment.Frame) -> rosetta.core.fragment.Frame   clone method, new frame with same alignment position, one fragments is copied as template ( valid() == false ) contains_seqpos(...) from builtins.PyCapsule contains_seqpos(self : rosetta.core.fragment.Frame, seqpos : int) -> bool   whether this fragment contains a certain position end(...) from builtins.PyCapsule end(rosetta.core.fragment.Frame) -> int   last sequence position affected by this frame frag_id(...) from builtins.PyCapsule frag_id(self : rosetta.core.fragment.Frame, frag_num : int) -> 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 fragment(...) from builtins.PyCapsule fragment(self : rosetta.core.fragment.Frame, frag_num : int) -> core::fragment::FragData   accesors for underlying FragData fragment_as_pose(...) from builtins.PyCapsule fragment_as_pose(self : rosetta.core.fragment.Frame, frag_num : int, pose : core::pose::Pose, restype_set : rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> NoneType   returns a (small) pose with fragment ( continous from seqpos 1 ... nr_res_affected() ) fragment_ptr(...) from builtins.PyCapsule fragment_ptr(self : rosetta.core.fragment.Frame, frag_num : int) -> core::fragment::FragData   accessor for underlying FragData as owning ptr generate_sub_frame(...) from builtins.PyCapsule generate_sub_frame(*args, **kwargs) Overloaded function.   1. generate_sub_frame(self : rosetta.core.fragment.Frame, length : int) -> rosetta.core.fragment.Frame   generate_sub_frame of length from start ( internal numbers )   2. generate_sub_frame(self : rosetta.core.fragment.Frame, length : int, start : int) -> rosetta.core.fragment.Frame   generate_sub_frame of length from start ( internal numbers ) is_applicable(...) from builtins.PyCapsule is_applicable(self : rosetta.core.fragment.Frame,  : core::kinematics::MoveMap) -> int   is the Frame applicable to the pose with the given movemap? is_continuous(...) from builtins.PyCapsule is_continuous(rosetta.core.fragment.Frame) -> bool   true if frame is continuous (always true for base class) is_mergeable(...) from builtins.PyCapsule is_mergeable(self : rosetta.core.fragment.Frame, other : rosetta.core.fragment.Frame) -> bool is_valid(...) from builtins.PyCapsule is_valid(rosetta.core.fragment.Frame) -> bool   a frame is considered valid if at least one fragment is contained and this fragment is also valid  (not an empty template fragment) length(...) from builtins.PyCapsule length(rosetta.core.fragment.Frame) -> int   number of residues in this frame ( for continuous frames it is the same as end()-start() + 1 ) merge(...) from builtins.PyCapsule merge(self : rosetta.core.fragment.Frame, other : rosetta.core.fragment.Frame) -> bool moves_residue(...) from builtins.PyCapsule moves_residue(self : rosetta.core.fragment.Frame, pos : int) -> bool nr_frags(...) from builtins.PyCapsule nr_frags(rosetta.core.fragment.Frame) -> int   number of fragments attached to this frame nr_res_affected(...) from builtins.PyCapsule nr_res_affected(self : rosetta.core.fragment.Frame, mm : core::kinematics::MoveMap) -> int   number of residues affected by this frame seqpos(...) from builtins.PyCapsule seqpos(self : rosetta.core.fragment.Frame, intra_pos : int) -> int   translate intra-frame position into sequence position. (trivial for base-class) shift_by(...) from builtins.PyCapsule shift_by(self : rosetta.core.fragment.Frame, offset : int) -> NoneType   shift frame by offset relative to current start position ( change end accordingly ) shift_to(...) from builtins.PyCapsule shift_to(self : rosetta.core.fragment.Frame, setting : int) -> NoneType   shift to new start position ( change end accordingly ) start(...) from builtins.PyCapsule start(rosetta.core.fragment.Frame) -> int   first seqpos of this frame steal(...) from builtins.PyCapsule steal(self : rosetta.core.fragment.Frame, pose : core::pose::Pose) -> bool   obtain fragment from pose at frame position stop(...) from builtins.PyCapsule stop(rosetta.core.fragment.Frame) -> int   last sequence position affected by this frame type(...) from builtins.PyCapsule type(rosetta.core.fragment.Frame) -> str   type() is specifying the output name of the Frame in FragmentIO ("FRAME", "JUMPFRAME", etc)   class FrameIterator(ConstFrameIterator)       Method resolution order: FrameIterator ConstFrameIterator rosetta.std.iterator_std_forward_iterator_tag_core_fragment_Frame_long_core_fragment_Frame_*_core_fragment_Frame_&_t builtins.object Methods defined here: __add__(...) from builtins.PyCapsule __add__(self : rosetta.core.fragment.FrameIterator, offset : int) -> rosetta.core.fragment.FrameIterator __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.fragment.FrameIterator, it : rosetta.core.fragment.FrameIteratorWorker_) -> NoneType   2. __init__(rosetta.core.fragment.FrameIterator) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.FrameIterator, itr : rosetta.core.fragment.FrameIterator) -> rosetta.core.fragment.FrameIterator frame_ptr(...) from builtins.PyCapsule frame_ptr(rosetta.core.fragment.FrameIterator) -> rosetta.core.fragment.Frame plus_plus(...) from builtins.PyCapsule plus_plus(rosetta.core.fragment.FrameIterator) -> rosetta.core.fragment.FrameIterator Methods inherited from ConstFrameIterator: __eq__(...) from builtins.PyCapsule __eq__(self : rosetta.core.fragment.ConstFrameIterator, fi : rosetta.core.fragment.ConstFrameIterator) -> bool __ne__(...) from builtins.PyCapsule __ne__(self : rosetta.core.fragment.ConstFrameIterator, fi : rosetta.core.fragment.ConstFrameIterator) -> bool   class FrameIteratorWorker_(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.fragment.FrameIteratorWorker_) -> NoneType   2. __init__(rosetta.core.fragment.FrameIteratorWorker_, rosetta.core.fragment.FrameIteratorWorker_) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature.   class FrameList(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t)       Method resolution order: FrameList rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.fragment.FrameList) -> NoneType   2. __init__(self : rosetta.core.fragment.FrameList,  : rosetta.core.fragment.FrameList) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.FrameList) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.FrameList,  : rosetta.core.fragment.FrameList) -> rosetta.core.fragment.FrameList flat_size(...) from builtins.PyCapsule flat_size(rosetta.core.fragment.FrameList) -> int fragID(...) from builtins.PyCapsule fragID(self : rosetta.core.fragment.FrameList, flat_nr : int) -> core::fragment::FragID frame_vector(...) from builtins.PyCapsule frame_vector(rosetta.core.fragment.FrameList) -> rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t Methods inherited from rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t: __bool__(...) from builtins.PyCapsule __bool__(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> bool   Check whether the list is nonempty __contains__(...) from builtins.PyCapsule __contains__(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, core::fragment::Frame) -> bool   return true if item in the container __eq__(...) from builtins.PyCapsule __eq__(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> bool __getitem__(...) from builtins.PyCapsule __getitem__(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, int) -> core::fragment::Frame __iter__(...) from builtins.PyCapsule __iter__(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> iterator __len__(...) from builtins.PyCapsule __len__(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> int __ne__(...) from builtins.PyCapsule __ne__(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> bool __repr__(...) from builtins.PyCapsule __repr__(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> str __setitem__(...) from builtins.PyCapsule __setitem__(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, int, core::fragment::Frame) -> NoneType append(...) from builtins.PyCapsule append(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, core::fragment::Frame) -> NoneType   adds an element to the end back(...) from builtins.PyCapsule back(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> core::fragment::Frame   access the last element capacity(...) from builtins.PyCapsule capacity(std::vector<std::shared_ptr<core::fragment::Frame>, std::allocator<std::shared_ptr<core::fragment::Frame> > >) -> int   returns the number of elements that can be held in currently allocated storage clear(...) from builtins.PyCapsule clear(std::vector<std::shared_ptr<core::fragment::Frame>, std::allocator<std::shared_ptr<core::fragment::Frame> > >) -> NoneType   clears the contents count(...) from builtins.PyCapsule count(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, core::fragment::Frame) -> int   counts the elements that are equal to value erase(...) from builtins.PyCapsule erase(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, int) -> NoneType   erases element at index extend = _vector_extend_func(vec, othervec) # Vector compatibility: Adding 'extend' to all utility.vector* functions front(...) from builtins.PyCapsule front(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> core::fragment::Frame   access the first element l(...) from builtins.PyCapsule l(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> int   lower index max_size(...) from builtins.PyCapsule max_size(std::vector<std::shared_ptr<core::fragment::Frame>, std::allocator<std::shared_ptr<core::fragment::Frame> > >) -> int   returns the maximum possible number of elements pop(...) from builtins.PyCapsule pop(*args, **kwargs) Overloaded function.   1. pop(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> core::fragment::Frame   remove and return last item   2. pop(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, int) -> core::fragment::Frame   remove and return item at index remove(...) from builtins.PyCapsule remove(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, core::fragment::Frame) -> NoneType   Remove the first item from the list whose value is x. It is an error if there is no such item. reserve(...) from builtins.PyCapsule reserve(std::vector<std::shared_ptr<core::fragment::Frame>, std::allocator<std::shared_ptr<core::fragment::Frame> > >, int) -> NoneType   reserves storage resize(...) from builtins.PyCapsule resize(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, int) -> NoneType   changes the number of elements stored shrink_to_fit(...) from builtins.PyCapsule shrink_to_fit(std::vector<std::shared_ptr<core::fragment::Frame>, std::allocator<std::shared_ptr<core::fragment::Frame> > >) -> NoneType   reduces memory usage by freeing unused memory u(...) from builtins.PyCapsule u(rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> int   upper index   class FrameListIterator_(FrameIteratorWorker_)       Method resolution order: FrameListIterator_ FrameIteratorWorker_ builtins.object Methods defined here: __init__(self, /, *args, **kwargs) Initialize self.  See help(type(self)) for accurate signature. __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature.   class IndependentBBTorsionSRFD(BBTorsionSRFD)     A version of BBTorsionSRFD that considers each torsion independently during is_applicable() and apply() calls when passed a MoveMap (vs the all-torsions-must-be-moveable-or-nothing-is behavior in the original BBTorsionSRFD).     Method resolution order: IndependentBBTorsionSRFD BBTorsionSRFD SecstructSRFD SingleResidueFragData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, n_bbtorsions : int, secstruct : str, sequence : str) -> NoneType   3. __init__(handle, rosetta.core.fragment.IndependentBBTorsionSRFD) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(self : rosetta.core.fragment.IndependentBBTorsionSRFD, movemap : core::kinematics::MoveMap, pose : core::pose::Pose, seqpos : int) -> bool   apply only torsions in this fragment marked as moveable in the given   MoveMap      Check for moveable torsions in this MoveMap.      The Pose to modify.      Insert at this sequence position.      True if at least one torsion inserted and second level superclass   SecstructSRFD::apply() succeeded, otherwise false. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.IndependentBBTorsionSRFD, rval : rosetta.core.fragment.IndependentBBTorsionSRFD) -> rosetta.core.fragment.IndependentBBTorsionSRFD   copy assignment clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.IndependentBBTorsionSRFD) -> rosetta.core.fragment.SingleResidueFragData   clone this object create(...) from builtins.PyCapsule create(rosetta.core.fragment.IndependentBBTorsionSRFD) -> rosetta.core.fragment.SingleResidueFragData   create a new instance of this object is_applicable(...) from builtins.PyCapsule is_applicable(self : rosetta.core.fragment.IndependentBBTorsionSRFD, movemap : core::kinematics::MoveMap, seqpos : int) -> bool   is at least one torsion marked as moveable in the given MoveMap?      Check for moveable torsions in this MoveMap.      Check at this sequence position.      True if at least one torsion moveable and second level superclass   SecstructSRFD::is_applicable(), otherwise False. Methods inherited from BBTorsionSRFD: has_coordinates(...) from builtins.PyCapsule has_coordinates(rosetta.core.fragment.BBTorsionSRFD) -> bool   Returns true if this instance contains cartesian coordinates,  false otherwise. Coordinates are available if the <write_ca_coords>  option is enabled in the new fragment picker and rosetta++ fragments  are used. is_compatible(...) from builtins.PyCapsule is_compatible(self : rosetta.core.fragment.BBTorsionSRFD,  : rosetta.core.fragment.SingleResidueFragData) -> bool nbb(...) from builtins.PyCapsule nbb(rosetta.core.fragment.BBTorsionSRFD) -> int   number of backbone torsions described by this fragment set_coordinates(...) from builtins.PyCapsule set_coordinates(self : rosetta.core.fragment.BBTorsionSRFD, x : float, y : float, z : float) -> NoneType   Convenience method for setting this residue's  CA coordinates all at once set_torsion(...) from builtins.PyCapsule set_torsion(self : rosetta.core.fragment.BBTorsionSRFD, tor : int, setting : float) -> NoneType   set value for specific torsion in this piece of fragment. steal(...) from builtins.PyCapsule steal(self : rosetta.core.fragment.BBTorsionSRFD,  : core::pose::Pose, seq_pos : int) -> bool torsion(...) from builtins.PyCapsule torsion(self : rosetta.core.fragment.BBTorsionSRFD, torsion_number : int) -> float   get the value for a specific torsion in this fragment type(...) from builtins.PyCapsule type(rosetta.core.fragment.BBTorsionSRFD) -> str x(...) from builtins.PyCapsule x(rosetta.core.fragment.BBTorsionSRFD) -> float   Returns the x coordinate of this residue's CA y(...) from builtins.PyCapsule y(rosetta.core.fragment.BBTorsionSRFD) -> float   Returns the y coordinate of this residue's CA z(...) from builtins.PyCapsule z(rosetta.core.fragment.BBTorsionSRFD) -> float   Returns the z coordinate of this residue's CA Methods inherited from SecstructSRFD: apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.SecstructSRFD,  : str, seq_pos : int) -> bool secstruct(...) from builtins.PyCapsule secstruct(rosetta.core.fragment.SecstructSRFD) -> str   get secstruct for this position set_secstruct(...) from builtins.PyCapsule set_secstruct(self : rosetta.core.fragment.SecstructSRFD, ss : str) -> NoneType Methods inherited from SingleResidueFragData: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.SingleResidueFragData) -> str sequence(...) from builtins.PyCapsule sequence(rosetta.core.fragment.SingleResidueFragData) -> str set_sequence(...) from builtins.PyCapsule set_sequence(self : rosetta.core.fragment.SingleResidueFragData, sequence : str) -> NoneType   class JumpingFrame(NonContinuousFrame)     JumpingFrame, so far there is nothing special about JumpingFrames. but I think we might want to have additionally information like the start and end residues that belong to a certain jump_nr.! okay: right now I require that the creator of a JumpingFrame sets start to the start-residue of the jump     Method resolution order: JumpingFrame NonContinuousFrame Frame builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   2. __init__(self : handle, start : int, end : int, length : int) -> NoneType   3. __init__(handle, rosetta.core.fragment.JumpingFrame) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.JumpingFrame,  : rosetta.core.fragment.JumpingFrame) -> rosetta.core.fragment.JumpingFrame clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.JumpingFrame) -> rosetta.core.fragment.Frame   clone method, new frame with same alignment position, fragments are not copied! type(...) from builtins.PyCapsule type(rosetta.core.fragment.JumpingFrame) -> str Methods inherited from NonContinuousFrame: align(...) from builtins.PyCapsule align(self : rosetta.core.fragment.NonContinuousFrame, map : rosetta.core.id.SequenceMapping) -> bool is_continuous(...) from builtins.PyCapsule is_continuous(rosetta.core.fragment.NonContinuousFrame) -> bool   true if frame is continuous moves_residue(...) from builtins.PyCapsule moves_residue(self : rosetta.core.fragment.NonContinuousFrame, pos : int) -> bool seqpos(...) from builtins.PyCapsule seqpos(self : rosetta.core.fragment.NonContinuousFrame, intra_pos : int) -> int   translate intra-frame position into sequence position. (trivial for base-class) set_pos(...) from builtins.PyCapsule set_pos(self : rosetta.core.fragment.NonContinuousFrame, intra_pos : int, setting : int) -> NoneType   assign sequence position or jump_nr to internal position pos shift_by(...) from builtins.PyCapsule shift_by(self : rosetta.core.fragment.NonContinuousFrame, offset : int) -> NoneType   shift frame by offset relative to current start position ( change end accordingly ) shift_to(...) from builtins.PyCapsule shift_to(self : rosetta.core.fragment.NonContinuousFrame, setting : int) -> NoneType   shift to new start position ( change end accordingly ) Methods inherited from Frame: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.Frame) -> str add_fragment(...) from builtins.PyCapsule add_fragment(*args, **kwargs) Overloaded function.   1. add_fragment(self : rosetta.core.fragment.Frame, new_frag : core::fragment::FragData) -> int   add a fragment .. return new frag_nr   2. add_fragment(self : rosetta.core.fragment.Frame, new_frags : rosetta.utility.vector1_std_shared_ptr_const_core_fragment_FragData_t) -> bool   add all fragments in list apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.Frame,  : core::kinematics::MoveMap, frag_num : int, pose : core::pose::Pose) -> int   insert fragment frag_num into pose   2. apply(self : rosetta.core.fragment.Frame, frag_num : int, pose : core::pose::Pose) -> int   insert fragment frag_num into pose --- ignore movemap apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.Frame,  : core::kinematics::MoveMap, frag_num : int, ss : str) -> int   change ss-string according to sec-struct info in fragments cache(...) from builtins.PyCapsule cache(self : rosetta.core.fragment.Frame, tag : str, new_cache : rosetta.core.fragment.BaseCacheUnit) -> rosetta.core.fragment.BaseCacheUnit   return handle to cached data stored under "tag"  shouldn't be called directly clear(...) from builtins.PyCapsule clear(rosetta.core.fragment.Frame) -> NoneType   remove all valid fragments, a template fragment will be left over clone_cache_data(...) from builtins.PyCapsule clone_cache_data(self : rosetta.core.fragment.Frame, source : rosetta.core.fragment.Frame, sid : int, nid : int) -> NoneType   copies all entries in the Frame-Cache for fragment "sid" of Frame "source" to fragment "nid" of "this" frame clone_with_frags(...) from builtins.PyCapsule clone_with_frags(rosetta.core.fragment.Frame) -> rosetta.core.fragment.Frame   clone method, new frame with same alignment position, fragments are not copied! clone_with_template(...) from builtins.PyCapsule clone_with_template(rosetta.core.fragment.Frame) -> rosetta.core.fragment.Frame   clone method, new frame with same alignment position, one fragments is copied as template ( valid() == false ) contains_seqpos(...) from builtins.PyCapsule contains_seqpos(self : rosetta.core.fragment.Frame, seqpos : int) -> bool   whether this fragment contains a certain position end(...) from builtins.PyCapsule end(rosetta.core.fragment.Frame) -> int   last sequence position affected by this frame frag_id(...) from builtins.PyCapsule frag_id(self : rosetta.core.fragment.Frame, frag_num : int) -> 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 fragment(...) from builtins.PyCapsule fragment(self : rosetta.core.fragment.Frame, frag_num : int) -> core::fragment::FragData   accesors for underlying FragData fragment_as_pose(...) from builtins.PyCapsule fragment_as_pose(self : rosetta.core.fragment.Frame, frag_num : int, pose : core::pose::Pose, restype_set : rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> NoneType   returns a (small) pose with fragment ( continous from seqpos 1 ... nr_res_affected() ) fragment_ptr(...) from builtins.PyCapsule fragment_ptr(self : rosetta.core.fragment.Frame, frag_num : int) -> core::fragment::FragData   accessor for underlying FragData as owning ptr generate_sub_frame(...) from builtins.PyCapsule generate_sub_frame(*args, **kwargs) Overloaded function.   1. generate_sub_frame(self : rosetta.core.fragment.Frame, length : int) -> rosetta.core.fragment.Frame   generate_sub_frame of length from start ( internal numbers )   2. generate_sub_frame(self : rosetta.core.fragment.Frame, length : int, start : int) -> rosetta.core.fragment.Frame   generate_sub_frame of length from start ( internal numbers ) is_applicable(...) from builtins.PyCapsule is_applicable(self : rosetta.core.fragment.Frame,  : core::kinematics::MoveMap) -> int   is the Frame applicable to the pose with the given movemap? is_mergeable(...) from builtins.PyCapsule is_mergeable(self : rosetta.core.fragment.Frame, other : rosetta.core.fragment.Frame) -> bool is_valid(...) from builtins.PyCapsule is_valid(rosetta.core.fragment.Frame) -> bool   a frame is considered valid if at least one fragment is contained and this fragment is also valid  (not an empty template fragment) length(...) from builtins.PyCapsule length(rosetta.core.fragment.Frame) -> int   number of residues in this frame ( for continuous frames it is the same as end()-start() + 1 ) merge(...) from builtins.PyCapsule merge(self : rosetta.core.fragment.Frame, other : rosetta.core.fragment.Frame) -> bool nr_frags(...) from builtins.PyCapsule nr_frags(rosetta.core.fragment.Frame) -> int   number of fragments attached to this frame nr_res_affected(...) from builtins.PyCapsule nr_res_affected(self : rosetta.core.fragment.Frame, mm : core::kinematics::MoveMap) -> int   number of residues affected by this frame start(...) from builtins.PyCapsule start(rosetta.core.fragment.Frame) -> int   first seqpos of this frame steal(...) from builtins.PyCapsule steal(self : rosetta.core.fragment.Frame, pose : core::pose::Pose) -> bool   obtain fragment from pose at frame position stop(...) from builtins.PyCapsule stop(rosetta.core.fragment.Frame) -> int   last sequence position affected by this frame   class MinimalFragSet(FragSet)       Method resolution order: MinimalFragSet FragSet builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.MinimalFragSet,  : rosetta.core.fragment.MinimalFragSet) -> rosetta.core.fragment.MinimalFragSet begin(...) from builtins.PyCapsule begin(rosetta.core.fragment.MinimalFragSet) -> rosetta.core.fragment.ConstFrameIterator clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.MinimalFragSet) -> rosetta.core.fragment.FragSet empty(...) from builtins.PyCapsule empty(rosetta.core.fragment.MinimalFragSet) -> bool empty_clone(...) from builtins.PyCapsule empty_clone(rosetta.core.fragment.MinimalFragSet) -> rosetta.core.fragment.FragSet end(...) from builtins.PyCapsule end(rosetta.core.fragment.MinimalFragSet) -> rosetta.core.fragment.ConstFrameIterator frames(...) from builtins.PyCapsule frames(self : rosetta.core.fragment.MinimalFragSet, pos : int, frames : rosetta.core.fragment.FrameList) -> int   Accessor for the Frame at the specified insertion position. Returns false if  there is no frame at the specified position. nonconst_begin(...) from builtins.PyCapsule nonconst_begin(rosetta.core.fragment.MinimalFragSet) -> rosetta.core.fragment.FrameIterator nonconst_end(...) from builtins.PyCapsule nonconst_end(rosetta.core.fragment.MinimalFragSet) -> rosetta.core.fragment.FrameIterator read_fragment_file(...) from builtins.PyCapsule read_fragment_file(*args, **kwargs) Overloaded function.   1. read_fragment_file(self : rosetta.core.fragment.MinimalFragSet, filename : str) -> NoneType   2. read_fragment_file(self : rosetta.core.fragment.MinimalFragSet, filename : str, top25 : int) -> NoneType   3. read_fragment_file(self : rosetta.core.fragment.MinimalFragSet, filename : str, top25 : int, ncopies : int) -> NoneType region(...) from builtins.PyCapsule region(self : rosetta.core.fragment.MinimalFragSet, mm : core::kinematics::MoveMap, start : int, end : int,  : int,  : int, frames : rosetta.core.fragment.FrameList) -> int Methods inherited from FragSet: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.FragSet) -> str add(...) from builtins.PyCapsule add(*args, **kwargs) Overloaded function.   1. add(self : rosetta.core.fragment.FragSet, aFrame : core::fragment::Frame) -> NoneType   add a single frame. if compatible frame is already in set the frames will be merged   2. add(self : rosetta.core.fragment.FragSet, frames : core::fragment::FrameList) -> NoneType   add all Frames in list   3. add(self : rosetta.core.fragment.FragSet, frames : rosetta.core.fragment.FragSet) -> NoneType   add all Frames in FragSet   4. add(self : rosetta.core.fragment.FragSet,  : core::fragment::FragID) -> NoneType   add single fragment clone_shifted(...) from builtins.PyCapsule clone_shifted(self : rosetta.core.fragment.FragSet,  : int) -> rosetta.core.fragment.FragSet generate_insert_map(...) from builtins.PyCapsule generate_insert_map(self : rosetta.core.fragment.FragSet, mm : core::kinematics::MoveMap, insert_map : rosetta.utility.vector1_unsigned_long, insert_size : rosetta.utility.vector1_unsigned_long) -> NoneType   InsertMap and InsertSize gives quick overview which residues can be affected by fragments.  insert_map --- list of start-positions, insert_size corresponding list of longest fragment at position x global_offset(...) from builtins.PyCapsule global_offset(*args, **kwargs) Overloaded function.   1. global_offset(rosetta.core.fragment.FragSet) -> int   2. global_offset(self : rosetta.core.fragment.FragSet,  : int) -> NoneType   resets global_offset of FragSet and shifts FragSet if necessary by calling shift_to max_frag_length(...) from builtins.PyCapsule max_frag_length(rosetta.core.fragment.FragSet) -> int   returns the longest fragment stored in this FragSet. max_pos(...) from builtins.PyCapsule max_pos(rosetta.core.fragment.FragSet) -> int   returns the maximal sequence position that can be affected by fragments in this set min_pos(...) from builtins.PyCapsule min_pos(rosetta.core.fragment.FragSet) -> int   returns the first sequence position that can be affected by fragments in this set nr_frames(...) from builtins.PyCapsule nr_frames(rosetta.core.fragment.FragSet) -> int   counts number of frames ( slow! - it really counts ) overlapping_with_region(...) from builtins.PyCapsule overlapping_with_region(self : rosetta.core.fragment.FragSet, mm : core::kinematics::MoveMap, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   returns the number and list of all fragment alignment frames that somehow overlap with the given region (also allows those frames that start before the region and reach into it) region_all(...) from builtins.PyCapsule region_all(self : rosetta.core.fragment.FragSet, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   return a list of frames that all sample the specified region, assume all motions are allowed region_simple(...) from builtins.PyCapsule region_simple(self : rosetta.core.fragment.FragSet, start : int, end : int, frames : core::fragment::FrameList) -> int   returns fragments that exactly span seq_pos start...end shift_by(...) from builtins.PyCapsule shift_by(self : rosetta.core.fragment.FragSet, offset : int) -> NoneType   shift all frames in FragSet by offset size(...) from builtins.PyCapsule size(rosetta.core.fragment.FragSet) -> int   returns total size--> counts together all frags in each frame   class MinimalFragSetIterator_(FrameIteratorWorker_)       Method resolution order: MinimalFragSetIterator_ FrameIteratorWorker_ builtins.object Methods defined here: __init__(self, /, *args, **kwargs) Initialize self.  See help(type(self)) for accurate signature. __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature.   class NonContinuousFrame(Frame)     JumpingFrame is a discontinuous frame i.e, the SRFDs stored in the FragData objects can be applied to residues anywhere a 5 7 9 Frame of a FragData containing three BBTorsionSRFDs would change torsions of 5 7 9 a 5 32 2 Frame of a FragData containing two BBTorsionSRFD and on JumpSRFD would change torsions of 5 and 32 and the RT of jump_nr 2 note that in the latter case the 2 is not coding for a residue number!   what is meaning of start() and end() ? If some of the positions are actually jump_nr should we ignore them for the start() / end() question ? or should we store which positions are jumps and translate into residue numbers from jump_nr ? could a MixedFrame contain Frames MixedFrame -- > non-cont-Frame, JumpFrame     Method resolution order: NonContinuousFrame Frame builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : handle, start : int, end : int, length : int) -> NoneType   2. __init__(handle, rosetta.core.fragment.NonContinuousFrame) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. align(...) from builtins.PyCapsule align(self : rosetta.core.fragment.NonContinuousFrame, map : rosetta.core.id.SequenceMapping) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.NonContinuousFrame,  : rosetta.core.fragment.NonContinuousFrame) -> rosetta.core.fragment.NonContinuousFrame clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.NonContinuousFrame) -> rosetta.core.fragment.Frame   clone method, new frame with same alignment position, fragments are not copied! is_continuous(...) from builtins.PyCapsule is_continuous(rosetta.core.fragment.NonContinuousFrame) -> bool   true if frame is continuous moves_residue(...) from builtins.PyCapsule moves_residue(self : rosetta.core.fragment.NonContinuousFrame, pos : int) -> bool seqpos(...) from builtins.PyCapsule seqpos(self : rosetta.core.fragment.NonContinuousFrame, intra_pos : int) -> int   translate intra-frame position into sequence position. (trivial for base-class) set_pos(...) from builtins.PyCapsule set_pos(self : rosetta.core.fragment.NonContinuousFrame, intra_pos : int, setting : int) -> NoneType   assign sequence position or jump_nr to internal position pos shift_by(...) from builtins.PyCapsule shift_by(self : rosetta.core.fragment.NonContinuousFrame, offset : int) -> NoneType   shift frame by offset relative to current start position ( change end accordingly ) shift_to(...) from builtins.PyCapsule shift_to(self : rosetta.core.fragment.NonContinuousFrame, setting : int) -> NoneType   shift to new start position ( change end accordingly ) Methods inherited from Frame: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.Frame) -> str add_fragment(...) from builtins.PyCapsule add_fragment(*args, **kwargs) Overloaded function.   1. add_fragment(self : rosetta.core.fragment.Frame, new_frag : core::fragment::FragData) -> int   add a fragment .. return new frag_nr   2. add_fragment(self : rosetta.core.fragment.Frame, new_frags : rosetta.utility.vector1_std_shared_ptr_const_core_fragment_FragData_t) -> bool   add all fragments in list apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.Frame,  : core::kinematics::MoveMap, frag_num : int, pose : core::pose::Pose) -> int   insert fragment frag_num into pose   2. apply(self : rosetta.core.fragment.Frame, frag_num : int, pose : core::pose::Pose) -> int   insert fragment frag_num into pose --- ignore movemap apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.Frame,  : core::kinematics::MoveMap, frag_num : int, ss : str) -> int   change ss-string according to sec-struct info in fragments cache(...) from builtins.PyCapsule cache(self : rosetta.core.fragment.Frame, tag : str, new_cache : rosetta.core.fragment.BaseCacheUnit) -> rosetta.core.fragment.BaseCacheUnit   return handle to cached data stored under "tag"  shouldn't be called directly clear(...) from builtins.PyCapsule clear(rosetta.core.fragment.Frame) -> NoneType   remove all valid fragments, a template fragment will be left over clone_cache_data(...) from builtins.PyCapsule clone_cache_data(self : rosetta.core.fragment.Frame, source : rosetta.core.fragment.Frame, sid : int, nid : int) -> NoneType   copies all entries in the Frame-Cache for fragment "sid" of Frame "source" to fragment "nid" of "this" frame clone_with_frags(...) from builtins.PyCapsule clone_with_frags(rosetta.core.fragment.Frame) -> rosetta.core.fragment.Frame   clone method, new frame with same alignment position, fragments are not copied! clone_with_template(...) from builtins.PyCapsule clone_with_template(rosetta.core.fragment.Frame) -> rosetta.core.fragment.Frame   clone method, new frame with same alignment position, one fragments is copied as template ( valid() == false ) contains_seqpos(...) from builtins.PyCapsule contains_seqpos(self : rosetta.core.fragment.Frame, seqpos : int) -> bool   whether this fragment contains a certain position end(...) from builtins.PyCapsule end(rosetta.core.fragment.Frame) -> int   last sequence position affected by this frame frag_id(...) from builtins.PyCapsule frag_id(self : rosetta.core.fragment.Frame, frag_num : int) -> 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 fragment(...) from builtins.PyCapsule fragment(self : rosetta.core.fragment.Frame, frag_num : int) -> core::fragment::FragData   accesors for underlying FragData fragment_as_pose(...) from builtins.PyCapsule fragment_as_pose(self : rosetta.core.fragment.Frame, frag_num : int, pose : core::pose::Pose, restype_set : rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) -> NoneType   returns a (small) pose with fragment ( continous from seqpos 1 ... nr_res_affected() ) fragment_ptr(...) from builtins.PyCapsule fragment_ptr(self : rosetta.core.fragment.Frame, frag_num : int) -> core::fragment::FragData   accessor for underlying FragData as owning ptr generate_sub_frame(...) from builtins.PyCapsule generate_sub_frame(*args, **kwargs) Overloaded function.   1. generate_sub_frame(self : rosetta.core.fragment.Frame, length : int) -> rosetta.core.fragment.Frame   generate_sub_frame of length from start ( internal numbers )   2. generate_sub_frame(self : rosetta.core.fragment.Frame, length : int, start : int) -> rosetta.core.fragment.Frame   generate_sub_frame of length from start ( internal numbers ) is_applicable(...) from builtins.PyCapsule is_applicable(self : rosetta.core.fragment.Frame,  : core::kinematics::MoveMap) -> int   is the Frame applicable to the pose with the given movemap? is_mergeable(...) from builtins.PyCapsule is_mergeable(self : rosetta.core.fragment.Frame, other : rosetta.core.fragment.Frame) -> bool is_valid(...) from builtins.PyCapsule is_valid(rosetta.core.fragment.Frame) -> bool   a frame is considered valid if at least one fragment is contained and this fragment is also valid  (not an empty template fragment) length(...) from builtins.PyCapsule length(rosetta.core.fragment.Frame) -> int   number of residues in this frame ( for continuous frames it is the same as end()-start() + 1 ) merge(...) from builtins.PyCapsule merge(self : rosetta.core.fragment.Frame, other : rosetta.core.fragment.Frame) -> bool nr_frags(...) from builtins.PyCapsule nr_frags(rosetta.core.fragment.Frame) -> int   number of fragments attached to this frame nr_res_affected(...) from builtins.PyCapsule nr_res_affected(self : rosetta.core.fragment.Frame, mm : core::kinematics::MoveMap) -> int   number of residues affected by this frame start(...) from builtins.PyCapsule start(rosetta.core.fragment.Frame) -> int   first seqpos of this frame steal(...) from builtins.PyCapsule steal(self : rosetta.core.fragment.Frame, pose : core::pose::Pose) -> bool   obtain fragment from pose at frame position stop(...) from builtins.PyCapsule stop(rosetta.core.fragment.Frame) -> int   last sequence position affected by this frame type(...) from builtins.PyCapsule type(rosetta.core.fragment.Frame) -> str   type() is specifying the output name of the Frame in FragmentIO ("FRAME", "JUMPFRAME", etc)   class OrderedFragSet(FragSet)       Method resolution order: OrderedFragSet FragSet builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(handle) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.OrderedFragSet,  : rosetta.core.fragment.OrderedFragSet) -> rosetta.core.fragment.OrderedFragSet begin(...) from builtins.PyCapsule begin(rosetta.core.fragment.OrderedFragSet) -> rosetta.core.fragment.ConstFrameIterator clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.OrderedFragSet) -> rosetta.core.fragment.FragSet empty(...) from builtins.PyCapsule empty(rosetta.core.fragment.OrderedFragSet) -> bool empty_clone(...) from builtins.PyCapsule empty_clone(rosetta.core.fragment.OrderedFragSet) -> rosetta.core.fragment.FragSet end(...) from builtins.PyCapsule end(rosetta.core.fragment.OrderedFragSet) -> rosetta.core.fragment.ConstFrameIterator frames(...) from builtins.PyCapsule frames(self : rosetta.core.fragment.OrderedFragSet, pos : int, frames : rosetta.core.fragment.FrameList) -> int   Accessor for the Frame at the specified insertion position. Returns false if  there is no frame at the specified position. nonconst_begin(...) from builtins.PyCapsule nonconst_begin(rosetta.core.fragment.OrderedFragSet) -> rosetta.core.fragment.FrameIterator nonconst_end(...) from builtins.PyCapsule nonconst_end(rosetta.core.fragment.OrderedFragSet) -> rosetta.core.fragment.FrameIterator region(...) from builtins.PyCapsule region(self : rosetta.core.fragment.OrderedFragSet, mm : core::kinematics::MoveMap, start : int, end : int,  : int,  : int, frames : rosetta.core.fragment.FrameList) -> int Methods inherited from FragSet: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.FragSet) -> str add(...) from builtins.PyCapsule add(*args, **kwargs) Overloaded function.   1. add(self : rosetta.core.fragment.FragSet, aFrame : core::fragment::Frame) -> NoneType   add a single frame. if compatible frame is already in set the frames will be merged   2. add(self : rosetta.core.fragment.FragSet, frames : core::fragment::FrameList) -> NoneType   add all Frames in list   3. add(self : rosetta.core.fragment.FragSet, frames : rosetta.core.fragment.FragSet) -> NoneType   add all Frames in FragSet   4. add(self : rosetta.core.fragment.FragSet,  : core::fragment::FragID) -> NoneType   add single fragment clone_shifted(...) from builtins.PyCapsule clone_shifted(self : rosetta.core.fragment.FragSet,  : int) -> rosetta.core.fragment.FragSet generate_insert_map(...) from builtins.PyCapsule generate_insert_map(self : rosetta.core.fragment.FragSet, mm : core::kinematics::MoveMap, insert_map : rosetta.utility.vector1_unsigned_long, insert_size : rosetta.utility.vector1_unsigned_long) -> NoneType   InsertMap and InsertSize gives quick overview which residues can be affected by fragments.  insert_map --- list of start-positions, insert_size corresponding list of longest fragment at position x global_offset(...) from builtins.PyCapsule global_offset(*args, **kwargs) Overloaded function.   1. global_offset(rosetta.core.fragment.FragSet) -> int   2. global_offset(self : rosetta.core.fragment.FragSet,  : int) -> NoneType   resets global_offset of FragSet and shifts FragSet if necessary by calling shift_to max_frag_length(...) from builtins.PyCapsule max_frag_length(rosetta.core.fragment.FragSet) -> int   returns the longest fragment stored in this FragSet. max_pos(...) from builtins.PyCapsule max_pos(rosetta.core.fragment.FragSet) -> int   returns the maximal sequence position that can be affected by fragments in this set min_pos(...) from builtins.PyCapsule min_pos(rosetta.core.fragment.FragSet) -> int   returns the first sequence position that can be affected by fragments in this set nr_frames(...) from builtins.PyCapsule nr_frames(rosetta.core.fragment.FragSet) -> int   counts number of frames ( slow! - it really counts ) overlapping_with_region(...) from builtins.PyCapsule overlapping_with_region(self : rosetta.core.fragment.FragSet, mm : core::kinematics::MoveMap, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   returns the number and list of all fragment alignment frames that somehow overlap with the given region (also allows those frames that start before the region and reach into it) region_all(...) from builtins.PyCapsule region_all(self : rosetta.core.fragment.FragSet, start : int, end : int, min_overlap : int, min_length : int, frames : core::fragment::FrameList) -> int   return a list of frames that all sample the specified region, assume all motions are allowed region_simple(...) from builtins.PyCapsule region_simple(self : rosetta.core.fragment.FragSet, start : int, end : int, frames : core::fragment::FrameList) -> int   returns fragments that exactly span seq_pos start...end shift_by(...) from builtins.PyCapsule shift_by(self : rosetta.core.fragment.FragSet, offset : int) -> NoneType   shift all frames in FragSet by offset size(...) from builtins.PyCapsule size(rosetta.core.fragment.FragSet) -> int   returns total size--> counts together all frags in each frame   class OrderedFragSetIterator_(FrameIteratorWorker_)       Method resolution order: OrderedFragSetIterator_ FrameIteratorWorker_ builtins.object Methods defined here: __init__(self, /, *args, **kwargs) Initialize self.  See help(type(self)) for accurate signature. __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature.   class SecondaryStructure(builtins.object)     tiny helper class that knows the relative fractions of secondary structure  L,H,E       so far these fractions can be computed from a FragSet other input strategies are conceivable but not implemented, yet: eg. psipred files, a bunch of poses,     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(rosetta.core.fragment.SecondaryStructure) -> NoneType   2. __init__(rosetta.core.fragment.SecondaryStructure, rosetta.core.fragment.FragSet) -> NoneType   doc   3. __init__(rosetta.core.fragment.SecondaryStructure, rosetta.core.fragment.FragSet, int) -> NoneType   doc   4. __init__(self : rosetta.core.fragment.SecondaryStructure, frags : rosetta.core.fragment.FragSet, nres : int, bJustCenterResidue : bool) -> NoneType   5. __init__(self : rosetta.core.fragment.SecondaryStructure,  : core::pose::Pose) -> NoneType   6. __init__(self : rosetta.core.fragment.SecondaryStructure,  : rosetta.core.fragment.SecondaryStructure) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.SecondaryStructure) -> str assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.SecondaryStructure,  : rosetta.core.fragment.SecondaryStructure) -> rosetta.core.fragment.SecondaryStructure confidence(...) from builtins.PyCapsule confidence(self : rosetta.core.fragment.SecondaryStructure, pos : int) -> float   confidence at position extend(...) from builtins.PyCapsule extend(self : rosetta.core.fragment.SecondaryStructure,  : int) -> NoneType   extends with pure 'L' at end until requested size is reached. helix_fraction(...) from builtins.PyCapsule helix_fraction(self : rosetta.core.fragment.SecondaryStructure, pos : int) -> float   helix fraction at position loop_fraction(...) from builtins.PyCapsule loop_fraction(*args, **kwargs) Overloaded function.   1. loop_fraction(self : rosetta.core.fragment.SecondaryStructure, pos : int) -> float   return loop fraction at position   2. loop_fraction(rosetta.core.fragment.SecondaryStructure) -> ObjexxFCL::FArray1D<float>   return loop fraction - FArray read_from_file(...) from builtins.PyCapsule read_from_file(self : rosetta.core.fragment.SecondaryStructure, fn : str) -> NoneType   read from file read_psipred_ss2(...) from builtins.PyCapsule read_psipred_ss2(self : rosetta.core.fragment.SecondaryStructure, filename : str) -> NoneType   write psipred format read_talos_ss(...) from builtins.PyCapsule read_talos_ss(self : rosetta.core.fragment.SecondaryStructure, filename : str) -> NoneType   read talos+ format secstruct(...) from builtins.PyCapsule secstruct(self : rosetta.core.fragment.SecondaryStructure, pos : int) -> str   returns the most probably secstruct at that position set_fractions(...) from builtins.PyCapsule set_fractions(*args, **kwargs) Overloaded function.   1. set_fractions(self : rosetta.core.fragment.SecondaryStructure, pos : int, helix_fraction : float, sheet_fraction : float, loop_fraction : float) -> NoneType   sets secondary structure probabilities at a given position   2. set_fractions(self : rosetta.core.fragment.SecondaryStructure, pos : int, helix_fraction : float, sheet_fraction : float, loop_fraction : float, confidence : float) -> NoneType   sets secondary structure probabilities at a given position sheet_fraction(...) from builtins.PyCapsule sheet_fraction(self : rosetta.core.fragment.SecondaryStructure, pos : int) -> float   alias for strand-fraction ... strand_fraction(...) from builtins.PyCapsule strand_fraction(*args, **kwargs) Overloaded function.   1. strand_fraction(self : rosetta.core.fragment.SecondaryStructure, pos : int) -> float   return strand fraction at position   2. strand_fraction(rosetta.core.fragment.SecondaryStructure) -> ObjexxFCL::FArray1D<float>   return strand fraction - FArray total_residue(...) from builtins.PyCapsule total_residue(rosetta.core.fragment.SecondaryStructure) -> int   number of residues for which information is available   class SecstructSRFD(SingleResidueFragData)       Method resolution order: SecstructSRFD SingleResidueFragData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   doc   2. __init__(handle, str) -> NoneType   doc   3. __init__(self : handle, secstruct : str, sequence : str) -> NoneType   4. __init__(handle, rosetta.core.fragment.SecstructSRFD) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.SecstructSRFD,  : core::pose::Pose, seq_pos : int) -> bool   2. apply(self : rosetta.core.fragment.SecstructSRFD,  : core::kinematics::MoveMap, pose : core::pose::Pose, seqpos : int) -> bool   apply secondary structure fragment data to the pose, movemap has no effect      In this version of apply(), by convention MoveMap has no effect   because a setting for sec.struct currently does not exist within the map.      always true apply_ss(...) from builtins.PyCapsule apply_ss(self : rosetta.core.fragment.SecstructSRFD,  : str, seq_pos : int) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.SecstructSRFD,  : rosetta.core.fragment.SecstructSRFD) -> rosetta.core.fragment.SecstructSRFD clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.SecstructSRFD) -> rosetta.core.fragment.SingleResidueFragData create(...) from builtins.PyCapsule create(rosetta.core.fragment.SecstructSRFD) -> rosetta.core.fragment.SingleResidueFragData   create a new instance of this object is_applicable(...) from builtins.PyCapsule is_applicable(self : rosetta.core.fragment.SecstructSRFD,  : core::kinematics::MoveMap, seq_pos : int) -> bool is_compatible(...) from builtins.PyCapsule is_compatible(self : rosetta.core.fragment.SecstructSRFD,  : rosetta.core.fragment.SingleResidueFragData) -> bool secstruct(...) from builtins.PyCapsule secstruct(rosetta.core.fragment.SecstructSRFD) -> str   get secstruct for this position set_secstruct(...) from builtins.PyCapsule set_secstruct(self : rosetta.core.fragment.SecstructSRFD, ss : str) -> NoneType steal(...) from builtins.PyCapsule steal(self : rosetta.core.fragment.SecstructSRFD,  : core::pose::Pose, seq_pos : int) -> bool type(...) from builtins.PyCapsule type(rosetta.core.fragment.SecstructSRFD) -> str Methods inherited from SingleResidueFragData: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.SingleResidueFragData) -> str sequence(...) from builtins.PyCapsule sequence(rosetta.core.fragment.SingleResidueFragData) -> str set_sequence(...) from builtins.PyCapsule set_sequence(self : rosetta.core.fragment.SingleResidueFragData, sequence : str) -> NoneType   class SingleResidueFragData(builtins.object)     TODO: change SRFD interface such that apply is called like this apply( pose, inframe_pos (1..length), Frame const& ) jumpFrags can then ask the Frame for their upstream residue and check that if they are at position 1 that they do nothgin... can have basic implementation that translates this apply into the old apply     Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(self : rosetta.core.fragment.SingleResidueFragData, sequence : str) -> NoneType   2. __init__(rosetta.core.fragment.SingleResidueFragData) -> NoneType   3. __init__(rosetta.core.fragment.SingleResidueFragData, rosetta.core.fragment.SingleResidueFragData) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.SingleResidueFragData) -> str apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.SingleResidueFragData,  : core::pose::Pose, seq_pos : int) -> bool   insert fragment_data into pose at position seq_pos   2. apply(self : rosetta.core.fragment.SingleResidueFragData, movemap : core::kinematics::MoveMap, pose : core::pose::Pose, seqpos : int) -> bool   insert fragment_data into pose at position seq_pos for dofs that are   allowed to move in the movemap      True if operation succeeds, False otherwise.   3. apply(self : rosetta.core.fragment.SingleResidueFragData,  : core::pose::Pose, intra_frame_pos : int,  : core::fragment::Frame) -> bool   insert fragment_data into pose at position given by Frame.seqpos( intra_frame_pos );   4. apply(self : rosetta.core.fragment.SingleResidueFragData, movemap : core::kinematics::MoveMap, pose : core::pose::Pose, intra_frame_pos : int, frame : core::fragment::Frame) -> bool   insert fragment_data into pose at position given by Frame.seqpos( intra_frame_pos )   for dofs that are allowed to move in the MoveMap apply_ss(...) from builtins.PyCapsule apply_ss(*args, **kwargs) Overloaded function.   1. apply_ss(self : rosetta.core.fragment.SingleResidueFragData,  : str, seq_pos : int) -> bool   insert fragment_data sec-struct into ss-string at position seq_pos   2. apply_ss(self : rosetta.core.fragment.SingleResidueFragData,  : str, intra_frame_pos : int,  : core::fragment::Frame) -> bool   insert fragment_data sec-struct into ss-string at position seq_pos assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.SingleResidueFragData,  : rosetta.core.fragment.SingleResidueFragData) -> rosetta.core.fragment.SingleResidueFragData clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.SingleResidueFragData) -> rosetta.core.fragment.SingleResidueFragData create(...) from builtins.PyCapsule create(rosetta.core.fragment.SingleResidueFragData) -> rosetta.core.fragment.SingleResidueFragData   create a new instance of this object is_applicable(...) from builtins.PyCapsule is_applicable(*args, **kwargs) Overloaded function.   1. is_applicable(self : rosetta.core.fragment.SingleResidueFragData,  : core::kinematics::MoveMap, intra_frame_pos : int,  : core::fragment::Frame) -> bool   check weather dofs can be moved   2. is_applicable(self : rosetta.core.fragment.SingleResidueFragData,  : core::kinematics::MoveMap, pos : int) -> bool   check whether dofs can be moved is_compatible(...) from builtins.PyCapsule is_compatible(self : rosetta.core.fragment.SingleResidueFragData,  : rosetta.core.fragment.SingleResidueFragData) -> bool   check weather SRFD applies to same dofs and is of same type secstruct(...) from builtins.PyCapsule secstruct(rosetta.core.fragment.SingleResidueFragData) -> str sequence(...) from builtins.PyCapsule sequence(rosetta.core.fragment.SingleResidueFragData) -> str set_sequence(...) from builtins.PyCapsule set_sequence(self : rosetta.core.fragment.SingleResidueFragData, sequence : str) -> NoneType steal(...) from builtins.PyCapsule steal(*args, **kwargs) Overloaded function.   1. steal(self : rosetta.core.fragment.SingleResidueFragData,  : core::pose::Pose, seq_pos : int) -> bool   insert fragment_data into pose at position seq_pos   2. steal(self : rosetta.core.fragment.SingleResidueFragData,  : core::pose::Pose, intra_frame_pos : int,  : core::fragment::Frame) -> bool   insert fragment_data into pose at position seq_pos type(...) from builtins.PyCapsule type(rosetta.core.fragment.SingleResidueFragData) -> str   class UpJumpSRFD(SingleResidueFragData)       Method resolution order: UpJumpSRFD SingleResidueFragData builtins.object Methods defined here: __init__(...) from builtins.PyCapsule __init__(*args, **kwargs) Overloaded function.   1. __init__(handle) -> NoneType   doc   2. __init__(self : handle, sequence : str) -> NoneType   3. __init__(handle, rosetta.core.fragment.UpJumpSRFD) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. apply(...) from builtins.PyCapsule apply(*args, **kwargs) Overloaded function.   1. apply(self : rosetta.core.fragment.UpJumpSRFD,  : core::pose::Pose,  : int,  : rosetta.core.fragment.Frame) -> bool   2. apply(self : rosetta.core.fragment.UpJumpSRFD,  : core::kinematics::MoveMap,  : core::pose::Pose,  : int,  : rosetta.core.fragment.Frame) -> bool   3. apply(self : rosetta.core.fragment.UpJumpSRFD,  : core::pose::Pose,  : int) -> bool   4. apply(self : rosetta.core.fragment.UpJumpSRFD,  : core::kinematics::MoveMap,  : core::pose::Pose,  : int) -> bool   for UpJumpSRFD this function should never be called, instead use Frame version      always false      will trigger a false runtime assert apply_ss(...) from builtins.PyCapsule apply_ss(*args, **kwargs) Overloaded function.   1. apply_ss(self : rosetta.core.fragment.UpJumpSRFD,  : str,  : int,  : rosetta.core.fragment.Frame) -> bool   2. apply_ss(self : rosetta.core.fragment.UpJumpSRFD,  : str,  : int) -> bool assign(...) from builtins.PyCapsule assign(self : rosetta.core.fragment.UpJumpSRFD,  : rosetta.core.fragment.UpJumpSRFD) -> rosetta.core.fragment.UpJumpSRFD clone(...) from builtins.PyCapsule clone(rosetta.core.fragment.UpJumpSRFD) -> rosetta.core.fragment.SingleResidueFragData   clone create(...) from builtins.PyCapsule create(rosetta.core.fragment.UpJumpSRFD) -> rosetta.core.fragment.SingleResidueFragData   create a new instance of this object is_applicable(...) from builtins.PyCapsule is_applicable(self : rosetta.core.fragment.UpJumpSRFD,  : core::kinematics::MoveMap,  : int) -> bool is_compatible(...) from builtins.PyCapsule is_compatible(self : rosetta.core.fragment.UpJumpSRFD,  : rosetta.core.fragment.SingleResidueFragData) -> bool steal(...) from builtins.PyCapsule steal(*args, **kwargs) Overloaded function.   1. steal(self : rosetta.core.fragment.UpJumpSRFD,  : core::pose::Pose,  : int,  : rosetta.core.fragment.Frame) -> bool   2. steal(self : rosetta.core.fragment.UpJumpSRFD,  : core::pose::Pose,  : int) -> bool type(...) from builtins.PyCapsule type(rosetta.core.fragment.UpJumpSRFD) -> str Methods inherited from SingleResidueFragData: __str__(...) from builtins.PyCapsule __str__(rosetta.core.fragment.SingleResidueFragData) -> str secstruct(...) from builtins.PyCapsule secstruct(rosetta.core.fragment.SingleResidueFragData) -> str sequence(...) from builtins.PyCapsule sequence(rosetta.core.fragment.SingleResidueFragData) -> str set_sequence(...) from builtins.PyCapsule set_sequence(self : rosetta.core.fragment.SingleResidueFragData, sequence : str) -> NoneType   class torsions(builtins.object)       Methods defined here: __init__(...) from builtins.PyCapsule __init__(rosetta.core.fragment.torsions) -> NoneType __new__(*args, **kwargs) from builtins.type Create and return a new object.  See help(type) for accurate signature. Data descriptors defined here: omega phi psi