fragment¶

picking_old

Bindings for core::fragment namespace

class pyrosetta.rosetta.core.fragment.AnnotatedFragData¶

Bases: pyrosetta.rosetta.core.fragment.FragData

FragData that contains additional information

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData, arg0: str, arg1: int) -> None

doc

__init__(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData, pdb_id: str, start_pos: int, chain: str) -> None
__init__(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData, arg0: str, arg1: int, arg2: pyrosetta.rosetta.core.fragment.FragData) -> None

doc

__init__(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData, pdb_id: str, start_pos: int, frag: pyrosetta.rosetta.core.fragment.FragData, chain: str) -> None
__init__(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData, arg0: pyrosetta.rosetta.core.fragment.AnnotatedFragData) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

__new__()¶: Create and return a new object. See help(type) for accurate signature.

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.fragment.FragData) → str¶

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_residue(self: pyrosetta.rosetta.core.fragment.FragData, res: pyrosetta.rosetta.core.fragment.SingleResidueFragData) → None¶: C++: core::fragment::FragData::add_residue(class std::shared_ptr<class core::fragment::SingleResidueFragData>) –> void

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.core.fragment.FragData, : core::kinematics::MoveMap, : core::pose::Pose, start: int, end: int) -> int

C++: core::fragment::FragData::apply(const class core::kinematics::MoveMap &, class core::pose::Pose &, unsigned long, unsigned long) const –> unsigned long

apply(self: pyrosetta.rosetta.core.fragment.FragData, : core::kinematics::MoveMap, : core::pose::Pose, : pyrosetta.rosetta.core.fragment.Frame) -> int

C++: core::fragment::FragData::apply(const class core::kinematics::MoveMap &, class core::pose::Pose &, const class core::fragment::Frame &) const –> unsigned long

apply(self: pyrosetta.rosetta.core.fragment.FragData, : core::pose::Pose, : pyrosetta.rosetta.core.fragment.Frame) -> int

C++: core::fragment::FragData::apply(class core::pose::Pose &, const class core::fragment::Frame &) const –> unsigned long

apply(self: pyrosetta.rosetta.core.fragment.FragData, : core::pose::Pose, start: int, end: int) -> int

C++: core::fragment::FragData::apply(class core::pose::Pose &, unsigned long, unsigned long) const –> unsigned long

apply_ss(self: pyrosetta.rosetta.core.fragment.FragData, : core::kinematics::MoveMap, ss: str, : pyrosetta.rosetta.core.fragment.Frame) → int¶: C++: core::fragment::FragData::apply_ss(const class core::kinematics::MoveMap &, class std::basic_string<char> &, const class core::fragment::Frame &) const –> unsigned long

assign(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData, : pyrosetta.rosetta.core.fragment.AnnotatedFragData) → pyrosetta.rosetta.core.fragment.AnnotatedFragData¶: C++: core::fragment::AnnotatedFragData::operator=(const class core::fragment::AnnotatedFragData &) –> class core::fragment::AnnotatedFragData &

chain(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData) → str¶: C++: core::fragment::AnnotatedFragData::chain() const –> char

clone(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData) → pyrosetta.rosetta.core.fragment.FragData¶: C++: core::fragment::AnnotatedFragData::clone() const –> class std::shared_ptr<class core::fragment::FragData>

copy(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData, frag_data: pyrosetta.rosetta.core.fragment.FragData) → None¶: C++: core::fragment::AnnotatedFragData::copy(const class core::fragment::FragData &) –> void

generate_sub_fragment(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData, start: int, stop: int) → pyrosetta.rosetta.core.fragment.FragData¶: C++: core::fragment::AnnotatedFragData::generate_sub_fragment(unsigned long, unsigned long) const –> class std::shared_ptr<class core::fragment::FragData>

get_residue(self: pyrosetta.rosetta.core.fragment.FragData, pos: int) → pyrosetta.rosetta.core.fragment.SingleResidueFragData¶: C++: core::fragment::FragData::get_residue(unsigned long) const –> class std::shared_ptr<const class core::fragment::SingleResidueFragData>

get_self_ptr(self: pyrosetta.rosetta.core.fragment.FragData) → pyrosetta.rosetta.core.fragment.FragData¶: C++: core::fragment::FragData::get_self_ptr() –> class std::shared_ptr<class core::fragment::FragData>

is_applicable(*args, **kwargs)¶

Overloaded function.

is_applicable(self: pyrosetta.rosetta.core.fragment.FragData, : core::kinematics::MoveMap, start: int, end: int) -> int

C++: core::fragment::FragData::is_applicable(const class core::kinematics::MoveMap &, unsigned long, unsigned long) const –> unsigned long

is_applicable(self: pyrosetta.rosetta.core.fragment.FragData, : core::kinematics::MoveMap, : pyrosetta.rosetta.core.fragment.Frame) -> int

C++: core::fragment::FragData::is_applicable(const class core::kinematics::MoveMap &, const class core::fragment::Frame &) const –> unsigned long

is_compatible(self: pyrosetta.rosetta.core.fragment.FragData, frag_data: pyrosetta.rosetta.core.fragment.FragData) → bool¶: C++: core::fragment::FragData::is_compatible(const class core::fragment::FragData &) const –> bool

is_valid(self: pyrosetta.rosetta.core.fragment.FragData) → bool¶: C++: core::fragment::FragData::is_valid() const –> bool

pdbid(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData) → str¶: C++: core::fragment::AnnotatedFragData::pdbid() const –> std::string

pdbpos(self: pyrosetta.rosetta.core.fragment.AnnotatedFragData) → int¶: C++: core::fragment::AnnotatedFragData::pdbpos() const –> unsigned long

score(self: pyrosetta.rosetta.core.fragment.FragData) → float¶

Returns the score for this fragment

C++: core::fragment::FragData::score() const –> double

secstruct(*args, **kwargs)¶

Overloaded function.

secstruct(self: pyrosetta.rosetta.core.fragment.FragData, pos: int) -> str

C++: core::fragment::FragData::secstruct(const unsigned long) const –> char

secstruct(self: pyrosetta.rosetta.core.fragment.FragData) -> str

C++: core::fragment::FragData::secstruct() const –> std::string

sequence(*args, **kwargs)¶

Overloaded function.

sequence(self: pyrosetta.rosetta.core.fragment.FragData, pos: int) -> str

C++: core::fragment::FragData::sequence(const unsigned long) const –> char

sequence(self: pyrosetta.rosetta.core.fragment.FragData) -> str

C++: core::fragment::FragData::sequence() const –> std::string

set_residue(self: pyrosetta.rosetta.core.fragment.FragData, pos: int, res: pyrosetta.rosetta.core.fragment.SingleResidueFragData) → None¶: C++: core::fragment::FragData::set_residue(unsigned long, class std::shared_ptr<class core::fragment::SingleResidueFragData>) –> void

set_score(self: pyrosetta.rosetta.core.fragment.FragData, score: float) → None¶

Set a score value for this fragment

C++: core::fragment::FragData::set_score(double) –> void

set_sequence(self: pyrosetta.rosetta.core.fragment.FragData, pos: int, setting: str) → None¶: C++: core::fragment::FragData::set_sequence(const unsigned long, const char) –> void

set_valid(*args, **kwargs)¶

Overloaded function.

set_valid(self: pyrosetta.rosetta.core.fragment.FragData) -> None
set_valid(self: pyrosetta.rosetta.core.fragment.FragData, setting: bool) -> None

C++: core::fragment::FragData::set_valid(bool) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.core.fragment.FragData, out: pyrosetta.rosetta.std.ostream) -> None

C++: core::fragment::FragData::show(class std::basic_ostream<char> &) const –> void

show(self: pyrosetta.rosetta.core.fragment.FragData, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.fragment.Frame) -> None

C++: core::fragment::FragData::show(class std::basic_ostream<char> &, const class core::fragment::Frame &) const –> void

show_classic(self: pyrosetta.rosetta.core.fragment.FragData, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::fragment::FragData::show_classic(class std::basic_ostream<char> &) const –> void

size(self: pyrosetta.rosetta.core.fragment.FragData) → int¶: C++: core::fragment::FragData::size() const –> unsigned long

steal(*args, **kwargs)¶

Overloaded function.

steal(self: pyrosetta.rosetta.core.fragment.FragData, : core::pose::Pose, start: int, end: int) -> bool

C++: core::fragment::FragData::steal(const class core::pose::Pose &, unsigned long, unsigned long) –> bool

steal(self: pyrosetta.rosetta.core.fragment.FragData, : core::pose::Pose, : pyrosetta.rosetta.core.fragment.Frame) -> bool

C++: core::fragment::FragData::steal(const class core::pose::Pose &, const class core::fragment::Frame &) –> bool

class pyrosetta.rosetta.core.fragment.ConstantLengthFragSet¶

Bases: pyrosetta.rosetta.core.fragment.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

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, frag_length: int) -> None
__init__(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, frag_length: int, filename: str) -> None
__init__(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) -> None
__init__(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, fragments: pyrosetta.rosetta.core.fragment.FragSet) -> None
__init__(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, arg0: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

__new__()¶: Create and return a new object. See help(type) for accurate signature.

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.fragment.FragSet) → str¶

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add(*args, **kwargs)¶

Overloaded function.

add(self: pyrosetta.rosetta.core.fragment.FragSet, aFrame: core::fragment::Frame) -> None

add a single frame. if compatible frame is already in set the frames will be merged

C++: core::fragment::FragSet::add(class std::shared_ptr<const class core::fragment::Frame>) –> void

add(self: pyrosetta.rosetta.core.fragment.FragSet, frames: core::fragment::FrameList) -> None

add all Frames in list

C++: core::fragment::FragSet::add(const class core::fragment::FrameList &) –> void

add(self: pyrosetta.rosetta.core.fragment.FragSet, frames: pyrosetta.rosetta.core.fragment.FragSet) -> None

add all Frames in FragSet

C++: core::fragment::FragSet::add(const class core::fragment::FragSet &) –> void

add(self: pyrosetta.rosetta.core.fragment.FragSet, : core::fragment::FragID) -> None

add single fragment

C++: core::fragment::FragSet::add(const class core::fragment::FragID &) –> void

assign(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, : pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) → pyrosetta.rosetta.core.fragment.ConstantLengthFragSet¶: C++: core::fragment::ConstantLengthFragSet::operator=(const class core::fragment::ConstantLengthFragSet &) –> class core::fragment::ConstantLengthFragSet &

begin(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) → core::fragment::ConstFrameIterator¶

iterate over contents

C++: core::fragment::ConstantLengthFragSet::begin() const –> class core::fragment::ConstFrameIterator

clone(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) → pyrosetta.rosetta.core.fragment.FragSet¶: C++: core::fragment::ConstantLengthFragSet::clone() const –> class std::shared_ptr<class core::fragment::FragSet>

clone_shifted(self: pyrosetta.rosetta.core.fragment.FragSet, : int) → pyrosetta.rosetta.core.fragment.FragSet¶: C++: core::fragment::FragSet::clone_shifted(int) const –> class std::shared_ptr<class core::fragment::FragSet>

empty(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) → bool¶: C++: core::fragment::ConstantLengthFragSet::empty() const –> bool

empty_clone(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) → pyrosetta.rosetta.core.fragment.FragSet¶: C++: core::fragment::ConstantLengthFragSet::empty_clone() const –> class std::shared_ptr<class core::fragment::FragSet>

end(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) → core::fragment::ConstFrameIterator¶: C++: core::fragment::ConstantLengthFragSet::end() const –> class core::fragment::ConstFrameIterator

frames(self: pyrosetta.rosetta.core.fragment.FragSet, pos: int, frames: core::fragment::FrameList) → int¶

appends frames at sequence position pos to frames, returns nr of frames added

C++: core::fragment::FragSet::frames(unsigned long, class core::fragment::FrameList &) const –> unsigned long

generate_insert_map(self: pyrosetta.rosetta.core.fragment.FragSet, mm: core::kinematics::MoveMap, insert_map: pyrosetta.rosetta.utility.vector1_unsigned_long, insert_size: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶

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

C++: core::fragment::FragSet::generate_insert_map(const class core::kinematics::MoveMap &, class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> void

global_offset(*args, **kwargs)¶

Overloaded function.

global_offset(self: pyrosetta.rosetta.core.fragment.FragSet) -> int

C++: core::fragment::FragSet::global_offset() const –> int

global_offset(self: pyrosetta.rosetta.core.fragment.FragSet, : int) -> None

resets global_offset of FragSet and shifts FragSet if necessary by calling shift_to

C++: core::fragment::FragSet::global_offset(int) –> void

max_frag_length(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

returns the longest fragment stored in this FragSet.

C++: core::fragment::FragSet::max_frag_length() const –> unsigned long

max_pos(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

returns the maximal sequence position that can be affected by fragments in this set

C++: core::fragment::FragSet::max_pos() const –> unsigned long

min_pos(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

returns the first sequence position that can be affected by fragments in this set

C++: core::fragment::FragSet::min_pos() const –> unsigned long

nonconst_begin(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) → core::fragment::FrameIterator¶: C++: core::fragment::ConstantLengthFragSet::nonconst_begin() –> class core::fragment::FrameIterator

nonconst_end(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) → core::fragment::FrameIterator¶: C++: core::fragment::ConstantLengthFragSet::nonconst_end() –> class core::fragment::FrameIterator

nr_frames(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

counts number of frames ( slow! - it really counts )

C++: core::fragment::FragSet::nr_frames() const –> unsigned long

overlapping_with_region(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, mm: core::kinematics::MoveMap, start: int, end: int, min_overlap: int, min_length: int, frames: pyrosetta.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)

C++: core::fragment::ConstantLengthFragSet::overlapping_with_region(const class core::kinematics::MoveMap &, unsigned long, unsigned long, unsigned long, unsigned long, class core::fragment::FrameList &) const –> unsigned long

read_fragment_file(*args, **kwargs)¶

Overloaded function.

read_fragment_file(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, filename: str) -> None
read_fragment_file(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, filename: str, top25: int) -> None
read_fragment_file(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, filename: str, top25: int, ncopies: int) -> None
read_fragment_file(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, filename: str, top25: int, ncopies: int, bAnnotation: bool) -> None

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

C++: core::fragment::ConstantLengthFragSet::read_fragment_file(class std::basic_string<char>, unsigned long, unsigned long, bool) –> void

read_fragment_stream(*args, **kwargs)¶

Overloaded function.

read_fragment_stream(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, data: pyrosetta.rosetta.utility.io.izstream) -> None
read_fragment_stream(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, data: pyrosetta.rosetta.utility.io.izstream, top25: int) -> None
read_fragment_stream(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, data: pyrosetta.rosetta.utility.io.izstream, top25: int, ncopies: int) -> None
read_fragment_stream(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, data: pyrosetta.rosetta.utility.io.izstream, top25: int, ncopies: int, bAnnotation: bool) -> None

C++: core::fragment::ConstantLengthFragSet::read_fragment_stream(class utility::io::izstream &, unsigned long, unsigned long, bool) –> void

region(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, mm: core::kinematics::MoveMap, start: int, end: int, : int, : int, frames: pyrosetta.rosetta.core.fragment.FrameList) → int¶

there is only one Frame per position, end / max_overlap are ignored

C++: core::fragment::ConstantLengthFragSet::region(const class core::kinematics::MoveMap &, unsigned long, unsigned long, unsigned long, unsigned long, class core::fragment::FrameList &) const –> unsigned long

region_all(self: pyrosetta.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

C++: core::fragment::FragSet::region_all(unsigned long, unsigned long, unsigned long, unsigned long, class core::fragment::FrameList &) const –> unsigned long

region_simple(self: pyrosetta.rosetta.core.fragment.FragSet, start: int, end: int, frames: core::fragment::FrameList) → int¶

returns fragments that exactly span seq_pos start…end

C++: core::fragment::FragSet::region_simple(unsigned long, unsigned long, class core::fragment::FrameList &) const –> unsigned long

shift_by(self: pyrosetta.rosetta.core.fragment.FragSet, offset: int) → None¶

shift all frames in FragSet by offset

C++: core::fragment::FragSet::shift_by(int) –> void

size(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

returns total size–> counts together all frags in each frame

C++: core::fragment::FragSet::size() const –> unsigned long

class pyrosetta.rosetta.core.fragment.FragSet¶

Bases: pybind11_builtins.pybind11_object

The FragSet: (Interface Definition – Virtual BaseClass )

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.fragment.FragSet) -> None
__init__(self: pyrosetta.rosetta.core.fragment.FragSet, arg0: pyrosetta.rosetta.core.fragment.FragSet) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

__new__()¶: Create and return a new object. See help(type) for accurate signature.

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.fragment.FragSet) → str¶

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add(*args, **kwargs)¶

Overloaded function.

add(self: pyrosetta.rosetta.core.fragment.FragSet, aFrame: core::fragment::Frame) -> None

add a single frame. if compatible frame is already in set the frames will be merged

C++: core::fragment::FragSet::add(class std::shared_ptr<const class core::fragment::Frame>) –> void

add(self: pyrosetta.rosetta.core.fragment.FragSet, frames: core::fragment::FrameList) -> None

add all Frames in list

C++: core::fragment::FragSet::add(const class core::fragment::FrameList &) –> void

add(self: pyrosetta.rosetta.core.fragment.FragSet, frames: pyrosetta.rosetta.core.fragment.FragSet) -> None

add all Frames in FragSet

C++: core::fragment::FragSet::add(const class core::fragment::FragSet &) –> void

add(self: pyrosetta.rosetta.core.fragment.FragSet, : core::fragment::FragID) -> None

add single fragment

C++: core::fragment::FragSet::add(const class core::fragment::FragID &) –> void

assign(self: pyrosetta.rosetta.core.fragment.FragSet, : pyrosetta.rosetta.core.fragment.FragSet) → pyrosetta.rosetta.core.fragment.FragSet¶: C++: core::fragment::FragSet::operator=(const class core::fragment::FragSet &) –> class core::fragment::FragSet &

begin(self: pyrosetta.rosetta.core.fragment.FragSet) → core::fragment::ConstFrameIterator¶

iterate over contents

C++: core::fragment::FragSet::begin() const –> class core::fragment::ConstFrameIterator

clone(self: pyrosetta.rosetta.core.fragment.FragSet) → pyrosetta.rosetta.core.fragment.FragSet¶

clone and copy the pointer of all Frames (Frames will not be copied)

C++: core::fragment::FragSet::clone() const –> class std::shared_ptr<class core::fragment::FragSet>

clone_shifted(self: pyrosetta.rosetta.core.fragment.FragSet, : int) → pyrosetta.rosetta.core.fragment.FragSet¶: C++: core::fragment::FragSet::clone_shifted(int) const –> class std::shared_ptr<class core::fragment::FragSet>

empty(self: pyrosetta.rosetta.core.fragment.FragSet) → bool¶: C++: core::fragment::FragSet::empty() const –> bool

empty_clone(self: pyrosetta.rosetta.core.fragment.FragSet) → pyrosetta.rosetta.core.fragment.FragSet¶

create an empty clone

C++: core::fragment::FragSet::empty_clone() const –> class std::shared_ptr<class core::fragment::FragSet>

end(self: pyrosetta.rosetta.core.fragment.FragSet) → core::fragment::ConstFrameIterator¶: C++: core::fragment::FragSet::end() const –> class core::fragment::ConstFrameIterator

frames(self: pyrosetta.rosetta.core.fragment.FragSet, pos: int, frames: core::fragment::FrameList) → int¶

appends frames at sequence position pos to frames, returns nr of frames added

C++: core::fragment::FragSet::frames(unsigned long, class core::fragment::FrameList &) const –> unsigned long

generate_insert_map(self: pyrosetta.rosetta.core.fragment.FragSet, mm: core::kinematics::MoveMap, insert_map: pyrosetta.rosetta.utility.vector1_unsigned_long, insert_size: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶

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

C++: core::fragment::FragSet::generate_insert_map(const class core::kinematics::MoveMap &, class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> void

global_offset(*args, **kwargs)¶

Overloaded function.

global_offset(self: pyrosetta.rosetta.core.fragment.FragSet) -> int

C++: core::fragment::FragSet::global_offset() const –> int

global_offset(self: pyrosetta.rosetta.core.fragment.FragSet, : int) -> None

resets global_offset of FragSet and shifts FragSet if necessary by calling shift_to

C++: core::fragment::FragSet::global_offset(int) –> void

max_frag_length(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

returns the longest fragment stored in this FragSet.

C++: core::fragment::FragSet::max_frag_length() const –> unsigned long

max_pos(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

returns the maximal sequence position that can be affected by fragments in this set

C++: core::fragment::FragSet::max_pos() const –> unsigned long

min_pos(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

returns the first sequence position that can be affected by fragments in this set

C++: core::fragment::FragSet::min_pos() const –> unsigned long

nonconst_begin(self: pyrosetta.rosetta.core.fragment.FragSet) → core::fragment::FrameIterator¶

iterate over contents

C++: core::fragment::FragSet::nonconst_begin() –> class core::fragment::FrameIterator

nonconst_end(self: pyrosetta.rosetta.core.fragment.FragSet) → core::fragment::FrameIterator¶: C++: core::fragment::FragSet::nonconst_end() –> class core::fragment::FrameIterator

nr_frames(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

counts number of frames ( slow! - it really counts )

C++: core::fragment::FragSet::nr_frames() const –> unsigned long

overlapping_with_region(self: pyrosetta.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)

C++: core::fragment::FragSet::overlapping_with_region(const class core::kinematics::MoveMap &, unsigned long, unsigned long, unsigned long, unsigned long, class core::fragment::FrameList &) const –> unsigned long

region(self: pyrosetta.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.

C++: core::fragment::FragSet::region(const class core::kinematics::MoveMap &, unsigned long, unsigned long, unsigned long, unsigned long, class core::fragment::FrameList &) const –> unsigned long

region_all(self: pyrosetta.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

C++: core::fragment::FragSet::region_all(unsigned long, unsigned long, unsigned long, unsigned long, class core::fragment::FrameList &) const –> unsigned long

region_simple(self: pyrosetta.rosetta.core.fragment.FragSet, start: int, end: int, frames: core::fragment::FrameList) → int¶

returns fragments that exactly span seq_pos start…end

C++: core::fragment::FragSet::region_simple(unsigned long, unsigned long, class core::fragment::FrameList &) const –> unsigned long

shift_by(self: pyrosetta.rosetta.core.fragment.FragSet, offset: int) → None¶

shift all frames in FragSet by offset

C++: core::fragment::FragSet::shift_by(int) –> void

size(self: pyrosetta.rosetta.core.fragment.FragSet) → int¶

returns total size–> counts together all frags in each frame

C++: core::fragment::FragSet::size() const –> unsigned long

class pyrosetta.rosetta.core.fragment.Frame¶

Bases: pybind11_builtins.pybind11_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

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.

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.fragment.Frame) -> None
__init__(self: pyrosetta.rosetta.core.fragment.Frame, begin: int, end: int, nr_res: int) -> None
__init__(self: pyrosetta.rosetta.core.fragment.Frame, start: int, length: int) -> None
__init__(self: pyrosetta.rosetta.core.fragment.Frame, start: int) -> None
__init__(self: pyrosetta.rosetta.core.fragment.Frame, start: int, frag1: core::fragment::FragData) -> None
__init__(self: pyrosetta.rosetta.core.fragment.Frame, start: int, length: int, srfd: pyrosetta.rosetta.core.fragment.SingleResidueFragData) -> None
__init__(self: pyrosetta.rosetta.core.fragment.Frame, arg0: pyrosetta.rosetta.core.fragment.Frame) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

__new__()¶: Create and return a new object. See help(type) for accurate signature.

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.fragment.Frame) → str¶

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

_static_type_name() → str¶: C++: core::fragment::Frame::_static_type_name() –> std::string

add_fragment(*args, **kwargs)¶

Overloaded function.

add_fragment(self: pyrosetta.rosetta.core.fragment.Frame, new_frag: core::fragment::FragData) -> int

add a fragment .. return new frag_nr

C++: core::fragment::Frame::add_fragment(class std::shared_ptr<const class core::fragment::FragData>) –> unsigned long

add_fragment(self: pyrosetta.rosetta.core.fragment.Frame, new_frags: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_fragment_FragData_t) -> bool

add all fragments in list

C++: core::fragment::Frame::add_fragment(class utility::vector1<class std::shared_ptr<const class core::fragment::FragData>, class std::allocator<class std::shared_ptr<const class core::fragment::FragData> > >) –> bool

align(self: pyrosetta.rosetta.core.fragment.Frame, map: pyrosetta.rosetta.core.id.SequenceMapping) → bool¶

change frames residue numbers accoriding to map

C++: core::fragment::Frame::align(const class core::id::SequenceMapping &) –> bool

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap, frag_num: int, pose: core::pose::Pose) -> int

insert fragment frag_num into pose

C++: core::fragment::Frame::apply(const class core::kinematics::MoveMap &, unsigned long, class core::pose::Pose &) const –> unsigned long

apply(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, pose: core::pose::Pose) -> int

insert fragment frag_num into pose — ignore movemap

C++: core::fragment::Frame::apply(unsigned long, class core::pose::Pose &) const –> unsigned long

apply_ss(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap, frag_num: int, ss: str) → int¶

change ss-string according to sec-struct info in fragments

C++: core::fragment::Frame::apply_ss(const class core::kinematics::MoveMap &, unsigned long, class std::basic_string<char> &) const –> unsigned long

assign(self: pyrosetta.rosetta.core.fragment.Frame, : pyrosetta.rosetta.core.fragment.Frame) → pyrosetta.rosetta.core.fragment.Frame¶: C++: core::fragment::Frame::operator=(const class core::fragment::Frame &) –> class core::fragment::Frame &

cache(self: pyrosetta.rosetta.core.fragment.Frame, tag: str, new_cache: pyrosetta.rosetta.core.fragment.BaseCacheUnit) → pyrosetta.rosetta.core.fragment.BaseCacheUnit¶

return handle to cached data stored under “tag”: shouldn’t be called directly

C++: core::fragment::Frame::cache(class std::basic_string<char>, const class std::shared_ptr<class core::fragment::BaseCacheUnit> &) const –> class core::fragment::BaseCacheUnit &

clear(self: pyrosetta.rosetta.core.fragment.Frame) → None¶

remove all valid fragments, a template fragment will be left over

C++: core::fragment::Frame::clear() –> void

clone(self: pyrosetta.rosetta.core.fragment.Frame) → pyrosetta.rosetta.core.fragment.Frame¶

clone method, new frame with same alignment position, fragments are not copied!

C++: core::fragment::Frame::clone() const –> class std::shared_ptr<class core::fragment::Frame>

clone_cache_data(self: pyrosetta.rosetta.core.fragment.Frame, source: pyrosetta.rosetta.core.fragment.Frame, sid: int, nid: int) → None¶

copies all entries in the Frame-Cache for fragment “sid” of Frame “source” to fragment “nid” of “this” frame

C++: core::fragment::Frame::clone_cache_data(const class core::fragment::Frame &, unsigned long, unsigned long) –> void

clone_with_frags(self: pyrosetta.rosetta.core.fragment.Frame) → pyrosetta.rosetta.core.fragment.Frame¶

clone method, new frame with same alignment position, fragments are not copied!

C++: core::fragment::Frame::clone_with_frags() const –> class std::shared_ptr<class core::fragment::Frame>

clone_with_template(self: pyrosetta.rosetta.core.fragment.Frame) → pyrosetta.rosetta.core.fragment.Frame¶

clone method, new frame with same alignment position, one fragments is copied as template ( valid() == false )

C++: core::fragment::Frame::clone_with_template() –> class std::shared_ptr<class core::fragment::Frame>

contains_seqpos(self: pyrosetta.rosetta.core.fragment.Frame, seqpos: int) → bool¶

whether this fragment contains a certain position

C++: core::fragment::Frame::contains_seqpos(unsigned long) const –> bool

end(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

last sequence position affected by this frame

C++: core::fragment::Frame::end() const –> unsigned long

frag_id(self: pyrosetta.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

C++: core::fragment::Frame::frag_id(unsigned long) const –> unsigned long

fragment(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int) → core::fragment::FragData¶

accesors for underlying FragData

C++: core::fragment::Frame::fragment(unsigned long) const –> const class core::fragment::FragData &

fragment_as_pose(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, pose: core::pose::Pose, restype_set: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) → None¶

returns a (small) pose with fragment ( continous from seqpos 1 … nr_res_affected() )

C++: core::fragment::Frame::fragment_as_pose(unsigned long, class core::pose::Pose &, class std::weak_ptr<const class core::chemical::ResidueTypeSet>) const –> void

fragment_ptr(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int) → core::fragment::FragData¶

accessor for underlying FragData as owning ptr

C++: core::fragment::Frame::fragment_ptr(unsigned long) const –> class std::shared_ptr<const class core::fragment::FragData>

generate_sub_frame(*args, **kwargs)¶

Overloaded function.

generate_sub_frame(self: pyrosetta.rosetta.core.fragment.Frame, length: int) -> pyrosetta.rosetta.core.fragment.Frame
generate_sub_frame(self: pyrosetta.rosetta.core.fragment.Frame, length: int, start: int) -> pyrosetta.rosetta.core.fragment.Frame

generate_sub_frame of length from start ( internal numbers )

C++: core::fragment::Frame::generate_sub_frame(unsigned long, unsigned long) const –> class std::shared_ptr<class core::fragment::Frame>

is_applicable(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap) → int¶

is the Frame applicable to the pose with the given movemap?

C++: core::fragment::Frame::is_applicable(const class core::kinematics::MoveMap &) const –> unsigned long

is_continuous(self: pyrosetta.rosetta.core.fragment.Frame) → bool¶

true if frame is continuous (always true for base class)

C++: core::fragment::Frame::is_continuous() const –> bool

is_mergeable(self: pyrosetta.rosetta.core.fragment.Frame, other: pyrosetta.rosetta.core.fragment.Frame) → bool¶: C++: core::fragment::Frame::is_mergeable(const class core::fragment::Frame &) const –> bool

is_valid(self: pyrosetta.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)

C++: core::fragment::Frame::is_valid() const –> bool

length(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

number of residues in this frame ( for continuous frames it is the same as end()-start() + 1 )

C++: core::fragment::Frame::length() const –> unsigned long

merge(self: pyrosetta.rosetta.core.fragment.Frame, other: pyrosetta.rosetta.core.fragment.Frame) → bool¶: C++: core::fragment::Frame::merge(const class core::fragment::Frame &) –> bool

moves_residue(self: pyrosetta.rosetta.core.fragment.Frame, pos: int) → bool¶: C++: core::fragment::Frame::moves_residue(unsigned long) const –> bool

nr_frags(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

number of fragments attached to this frame

C++: core::fragment::Frame::nr_frags() const –> unsigned long

nr_res_affected(self: pyrosetta.rosetta.core.fragment.Frame, mm: core::kinematics::MoveMap) → int¶

number of residues affected by this frame

C++: core::fragment::Frame::nr_res_affected(const class core::kinematics::MoveMap &) const –> unsigned long

read(self: pyrosetta.rosetta.core.fragment.Frame, in: pyrosetta.rosetta.std.istream) → None¶: C++: core::fragment::Frame::read(class std::basic_istream<char> &) –> void

seqpos(self: pyrosetta.rosetta.core.fragment.Frame, intra_pos: int) → int¶

translate intra-frame position into sequence position. (trivial for base-class)

C++: core::fragment::Frame::seqpos(unsigned long) const –> unsigned long

shift_by(self: pyrosetta.rosetta.core.fragment.Frame, offset: int) → None¶

shift frame by offset relative to current start position ( change end accordingly )

C++: core::fragment::Frame::shift_by(int) –> void

shift_to(self: pyrosetta.rosetta.core.fragment.Frame, setting: int) → None¶

shift to new start position ( change end accordingly )

C++: core::fragment::Frame::shift_to(unsigned long) –> void

show(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::fragment::Frame::show(class std::basic_ostream<char> &) const –> void

show_classic(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::fragment::Frame::show_classic(class std::basic_ostream<char> &) const –> void

show_header(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::fragment::Frame::show_header(class std::basic_ostream<char> &) const –> void

start(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

first seqpos of this frame

C++: core::fragment::Frame::start() const –> unsigned long

steal(self: pyrosetta.rosetta.core.fragment.Frame, pose: core::pose::Pose) → bool¶

obtain fragment from pose at frame position

C++: core::fragment::Frame::steal(const class core::pose::Pose &) –> bool

stop(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

last sequence position affected by this frame

C++: core::fragment::Frame::stop() const –> unsigned long

type(self: pyrosetta.rosetta.core.fragment.Frame) → str¶

type() is specifying the output name of the Frame in FragmentIO (“FRAME”, “JUMPFRAME”, etc)

C++: core::fragment::Frame::type() const –> std::string

class pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD¶

Bases: pyrosetta.rosetta.core.fragment.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).

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD) -> None
__init__(self: pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD, n_bbtorsions: int, secstruct: str, sequence: str) -> None
__init__(self: pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD, arg0: pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

__new__()¶: Create and return a new object. See help(type) for accurate signature.

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData) → str¶

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

_static_type_name() → str¶: C++: core::fragment::BBTorsionSRFD::_static_type_name() –> std::string

apply(self: pyrosetta.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.

C++: core::fragment::IndependentBBTorsionSRFD::apply(const class core::kinematics::MoveMap &, class core::pose::Pose &, const unsigned long) const –> bool

apply_ss(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, : str, seq_pos: int) → bool¶: C++: core::fragment::SecstructSRFD::apply_ss(class std::basic_string<char> &, unsigned long) const –> bool

assign(self: pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD, rval: pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD) → pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD¶

copy assignment

C++: core::fragment::IndependentBBTorsionSRFD::operator=(const class core::fragment::IndependentBBTorsionSRFD &) –> class core::fragment::IndependentBBTorsionSRFD &

clone(self: pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD) → pyrosetta.rosetta.core.fragment.SingleResidueFragData¶

clone this object

C++: core::fragment::IndependentBBTorsionSRFD::clone() const –> class std::shared_ptr<class core::fragment::SingleResidueFragData>

create(self: pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD) → pyrosetta.rosetta.core.fragment.SingleResidueFragData¶

create a new instance of this object

C++: core::fragment::IndependentBBTorsionSRFD::create() const –> class std::shared_ptr<class core::fragment::SingleResidueFragData>

has_coordinates(self: pyrosetta.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.

C++: core::fragment::BBTorsionSRFD::has_coordinates() const –> bool

is_applicable(self: pyrosetta.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.

C++: core::fragment::IndependentBBTorsionSRFD::is_applicable(const class core::kinematics::MoveMap &, unsigned long) const –> bool

is_compatible(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, : pyrosetta.rosetta.core.fragment.SingleResidueFragData) → bool¶: C++: core::fragment::BBTorsionSRFD::is_compatible(const class core::fragment::SingleResidueFragData &) const –> bool

nbb(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD) → int¶

number of backbone torsions described by this fragment

C++: core::fragment::BBTorsionSRFD::nbb() const –> unsigned long

read_data(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, in: pyrosetta.rosetta.std.istream) → None¶: C++: core::fragment::BBTorsionSRFD::read_data(class std::basic_istream<char> &) –> void

secstruct(self: pyrosetta.rosetta.core.fragment.SecstructSRFD) → str¶

get secstruct for this position

C++: core::fragment::SecstructSRFD::secstruct() const –> char

sequence(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData) → str¶: C++: core::fragment::SingleResidueFragData::sequence() const –> char

set_coordinates(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, x: float, y: float, z: float) → None¶

Convenience method for setting this residue’s: CA coordinates all at once

C++: core::fragment::BBTorsionSRFD::set_coordinates(double, double, double) –> void

set_secstruct(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, ss: str) → None¶: C++: core::fragment::SecstructSRFD::set_secstruct(const char) –> void

set_sequence(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, sequence: str) → None¶: C++: core::fragment::SingleResidueFragData::set_sequence(const char) –> void

set_torsion(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, tor: int, setting: float) → None¶

set value for specific torsion in this piece of fragment.

C++: core::fragment::BBTorsionSRFD::set_torsion(const unsigned long, const double) –> void

show(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::fragment::BBTorsionSRFD::show(class std::basic_ostream<char> &) const –> void

steal(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, : core::pose::Pose, seq_pos: int) → bool¶: C++: core::fragment::BBTorsionSRFD::steal(const class core::pose::Pose &, unsigned long) –> bool

torsion(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, torsion_number: int) → float¶

get the value for a specific torsion in this fragment

C++: core::fragment::BBTorsionSRFD::torsion(const unsigned long) const –> double

type(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD) → str¶: C++: core::fragment::BBTorsionSRFD::type() const –> std::string

x(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD) → float¶

Returns the x coordinate of this residue’s CA

C++: core::fragment::BBTorsionSRFD::x() const –> double

y(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD) → float¶

Returns the y coordinate of this residue’s CA

C++: core::fragment::BBTorsionSRFD::y() const –> double

z(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD) → float¶

Returns the z coordinate of this residue’s CA

C++: core::fragment::BBTorsionSRFD::z() const –> double

class pyrosetta.rosetta.core.fragment.JumpingFrame¶

Bases: pyrosetta.rosetta.core.fragment.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

__delattr__¶: Implement delattr(self, name).

__dir__() → list¶: default dir() implementation

__eq__¶: Return self==value.

__format__()¶: default object formatter

__ge__¶: Return self>=value.

__getattribute__¶: Return getattr(self, name).

__gt__¶: Return self>value.

__hash__¶: Return hash(self).

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: pyrosetta.rosetta.core.fragment.JumpingFrame) -> None
__init__(self: pyrosetta.rosetta.core.fragment.JumpingFrame, start: int, end: int, length: int) -> None
__init__(self: pyrosetta.rosetta.core.fragment.JumpingFrame, arg0: pyrosetta.rosetta.core.fragment.JumpingFrame) -> None

__init_subclass__()¶

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__¶: Return self<=value.

__lt__¶: Return self<value.

__ne__¶: Return self!=value.

__new__()¶: Create and return a new object. See help(type) for accurate signature.

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶: Return repr(self).

__setattr__¶: Implement setattr(self, name, value).

__sizeof__() → int¶: size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.fragment.Frame) → str¶

__subclasshook__()¶

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

_static_type_name() → str¶: C++: core::fragment::JumpingFrame::_static_type_name() –> std::string

add_fragment(*args, **kwargs)¶

Overloaded function.

add_fragment(self: pyrosetta.rosetta.core.fragment.Frame, new_frag: core::fragment::FragData) -> int

add a fragment .. return new frag_nr

C++: core::fragment::Frame::add_fragment(class std::shared_ptr<const class core::fragment::FragData>) –> unsigned long

add_fragment(self: pyrosetta.rosetta.core.fragment.Frame, new_frags: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_fragment_FragData_t) -> bool

add all fragments in list

C++: core::fragment::Frame::add_fragment(class utility::vector1<class std::shared_ptr<const class core::fragment::FragData>, class std::allocator<class std::shared_ptr<const class core::fragment::FragData> > >) –> bool

align(self: pyrosetta.rosetta.core.fragment.NonContinuousFrame, map: pyrosetta.rosetta.core.id.SequenceMapping) → bool¶: C++: core::fragment::NonContinuousFrame::align(const class core::id::SequenceMapping &) –> bool

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap, frag_num: int, pose: core::pose::Pose) -> int

insert fragment frag_num into pose

C++: core::fragment::Frame::apply(const class core::kinematics::MoveMap &, unsigned long, class core::pose::Pose &) const –> unsigned long

apply(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, pose: core::pose::Pose) -> int

insert fragment frag_num into pose — ignore movemap

C++: core::fragment::Frame::apply(unsigned long, class core::pose::Pose &) const –> unsigned long

apply_ss(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap, frag_num: int, ss: str) → int¶

change ss-string according to sec-struct info in fragments

C++: core::fragment::Frame::apply_ss(const class core::kinematics::MoveMap &, unsigned long, class std::basic_string<char> &) const –> unsigned long

assign(self: pyrosetta.rosetta.core.fragment.JumpingFrame, : pyrosetta.rosetta.core.fragment.JumpingFrame) → pyrosetta.rosetta.core.fragment.JumpingFrame¶: C++: core::fragment::JumpingFrame::operator=(const class core::fragment::JumpingFrame &) –> class core::fragment::JumpingFrame &

cache(self: pyrosetta.rosetta.core.fragment.Frame, tag: str, new_cache: pyrosetta.rosetta.core.fragment.BaseCacheUnit) → pyrosetta.rosetta.core.fragment.BaseCacheUnit¶

return handle to cached data stored under “tag”: shouldn’t be called directly

C++: core::fragment::Frame::cache(class std::basic_string<char>, const class std::shared_ptr<class core::fragment::BaseCacheUnit> &) const –> class core::fragment::BaseCacheUnit &

clear(self: pyrosetta.rosetta.core.fragment.Frame) → None¶

remove all valid fragments, a template fragment will be left over

C++: core::fragment::Frame::clear() –> void

clone(self: pyrosetta.rosetta.core.fragment.JumpingFrame) → pyrosetta.rosetta.core.fragment.Frame¶

clone method, new frame with same alignment position, fragments are not copied!

C++: core::fragment::JumpingFrame::clone() const –> class std::shared_ptr<class core::fragment::Frame>