fragment

• picking_old
• rna

Bindings for core::fragment namespace

class pyrosetta.rosetta.core.fragment.AnnotatedFragData

Bases: FragData

FragData that contains additional information

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.

1. apply(self: pyrosetta.rosetta.core.fragment.FragData, : core::kinematics::MoveMap, : pyrosetta.rosetta.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

2. apply(self: pyrosetta.rosetta.core.fragment.FragData, : core::kinematics::MoveMap, : pyrosetta.rosetta.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

3. apply(self: pyrosetta.rosetta.core.fragment.FragData, : pyrosetta.rosetta.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

4. apply(self: pyrosetta.rosetta.core.fragment.FragData, : pyrosetta.rosetta.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 &, std::string &, 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.

1. 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

2. 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.

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

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

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

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

sequence(*args, **kwargs)

Overloaded function.

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

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

2. 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.

1. set_valid(self: pyrosetta.rosetta.core.fragment.FragData) -> None

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

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

show(*args, **kwargs)

Overloaded function.

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

C++: core::fragment::FragData::show(std::ostream &) const –> void

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

C++: core::fragment::FragData::show(std::ostream &, 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(std::ostream &) const –> void

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

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

steal(*args, **kwargs)

Overloaded function.

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

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

2. steal(self: pyrosetta.rosetta.core.fragment.FragData, : pyrosetta.rosetta.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.BBTorsionAndAnglesSRFD

Bases: BBTorsionSRFD

static _static_type_name() → str

C++: core::fragment::BBTorsionAndAnglesSRFD::_static_type_name() –> std::string

apply(*args, **kwargs)

Overloaded function.

1. apply(self: pyrosetta.rosetta.core.fragment.BBTorsionAndAnglesSRFD, : pyrosetta.rosetta.core.pose.Pose, seq_pos: int) -> bool

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

2. apply(self: pyrosetta.rosetta.core.fragment.BBTorsionAndAnglesSRFD, movemap: core::kinematics::MoveMap, pose: pyrosetta.rosetta.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.

C++: core::fragment::BBTorsionAndAnglesSRFD::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(std::string &, unsigned long) const –> bool

assign(self: pyrosetta.rosetta.core.fragment.BBTorsionAndAnglesSRFD, : pyrosetta.rosetta.core.fragment.BBTorsionAndAnglesSRFD) → pyrosetta.rosetta.core.fragment.BBTorsionAndAnglesSRFD

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

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

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

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

create a new instance of this object

C++: core::fragment::BBTorsionAndAnglesSRFD::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.BBTorsionAndAnglesSRFD, : core::kinematics::MoveMap, seq_pos: int) → bool

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

is_compatible(self: pyrosetta.rosetta.core.fragment.BBTorsionAndAnglesSRFD, : pyrosetta.rosetta.core.fragment.SingleResidueFragData) → bool

C++: core::fragment::BBTorsionAndAnglesSRFD::is_compatible(const class core::fragment::SingleResidueFragData &) const –> bool

nangles(self: pyrosetta.rosetta.core.fragment.BBTorsionAndAnglesSRFD) → int

C++: core::fragment::BBTorsionAndAnglesSRFD::nangles() const –> unsigned long

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(self: pyrosetta.rosetta.core.fragment.BBTorsionAndAnglesSRFD, in: pyrosetta.rosetta.std.istream) → None

C++: core::fragment::BBTorsionAndAnglesSRFD::read(std::istream &) –> void

read_data(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, in: pyrosetta.rosetta.std.istream) → None

C++: core::fragment::BBTorsionSRFD::read_data(std::istream &) –> 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.BBTorsionAndAnglesSRFD, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::BBTorsionAndAnglesSRFD::show(std::ostream &) const –> void

steal(self: pyrosetta.rosetta.core.fragment.BBTorsionAndAnglesSRFD, : pyrosetta.rosetta.core.pose.Pose, seq_pos: int) → bool

C++: core::fragment::BBTorsionAndAnglesSRFD::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.BBTorsionAndAnglesSRFD) → str

C++: core::fragment::BBTorsionAndAnglesSRFD::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.BBTorsionSRFD

Bases: SecstructSRFD

static _static_type_name() → str

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

apply(*args, **kwargs)

Overloaded function.

1. apply(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, : pyrosetta.rosetta.core.pose.Pose, seq_pos: int) -> bool

insert all backbone torsions into pose at position seq_pos

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

2. apply(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, movemap: core::kinematics::MoveMap, pose: pyrosetta.rosetta.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().

C++: core::fragment::BBTorsionSRFD::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(std::string &, unsigned long) const –> bool

assign(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, : pyrosetta.rosetta.core.fragment.BBTorsionSRFD) → pyrosetta.rosetta.core.fragment.BBTorsionSRFD

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

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

clone this object

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

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

create a new instance of this object

C++: core::fragment::BBTorsionSRFD::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.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.

C++: core::fragment::BBTorsionSRFD::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(std::istream &) –> 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(std::ostream &) const –> void

steal(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, : pyrosetta.rosetta.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.BaseCacheUnit

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.fragment.BaseCacheUnit, : pyrosetta.rosetta.core.fragment.BaseCacheUnit) → pyrosetta.rosetta.core.fragment.BaseCacheUnit

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

clone(self: pyrosetta.rosetta.core.fragment.BaseCacheUnit) → pyrosetta.rosetta.core.fragment.BaseCacheUnit

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

remap_value(self: pyrosetta.rosetta.core.fragment.BaseCacheUnit, source: pyrosetta.rosetta.core.fragment.BaseCacheUnit, source_id: int, new_id: int) → None

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

class pyrosetta.rosetta.core.fragment.CacheWrapper_protocols_simple_moves_GunnTuple_core_fragment_MapCacheUnit_protocols_simple_moves_GunnTuple_t

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.fragment.CacheWrapper_protocols_simple_moves_GunnTuple_core_fragment_MapCacheUnit_protocols_simple_moves_GunnTuple_t, : pyrosetta.rosetta.core.fragment.CacheWrapper_protocols_simple_moves_GunnTuple_core_fragment_MapCacheUnit_protocols_simple_moves_GunnTuple_t) → pyrosetta.rosetta.core.fragment.CacheWrapper_protocols_simple_moves_GunnTuple_core_fragment_MapCacheUnit_protocols_simple_moves_GunnTuple_t

C++: core::fragment::CacheWrapper<protocols::simple_moves::GunnTuple, core::fragment::MapCacheUnit<protocols::simple_moves::GunnTuple> >::operator=(const class core::fragment::CacheWrapper<struct protocols::simple_moves::GunnTuple, class core::fragment::MapCacheUnit<struct protocols::simple_moves::GunnTuple> > &) –> class core::fragment::CacheWrapper<struct protocols::simple_moves::GunnTuple, class core::fragment::MapCacheUnit<struct protocols::simple_moves::GunnTuple> > &

property new_cache_

store(*args, **kwargs)

Overloaded function.

1. store(self: pyrosetta.rosetta.core.fragment.CacheWrapper_protocols_simple_moves_GunnTuple_core_fragment_MapCacheUnit_protocols_simple_moves_GunnTuple_t, frame: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, score: protocols::simple_moves::GunnTuple) -> None

C++: core::fragment::CacheWrapper<protocols::simple_moves::GunnTuple, core::fragment::MapCacheUnit<protocols::simple_moves::GunnTuple> >::store(const class core::fragment::Frame &, unsigned long, const struct protocols::simple_moves::GunnTuple &) –> void

2. store(self: pyrosetta.rosetta.core.fragment.CacheWrapper_protocols_simple_moves_GunnTuple_core_fragment_MapCacheUnit_protocols_simple_moves_GunnTuple_t, frag_id: core::fragment::FragID, score: protocols::simple_moves::GunnTuple) -> None

C++: core::fragment::CacheWrapper<protocols::simple_moves::GunnTuple, core::fragment::MapCacheUnit<protocols::simple_moves::GunnTuple> >::store(const class core::fragment::FragID &, const struct protocols::simple_moves::GunnTuple &) –> void

property tag_

class pyrosetta.rosetta.core.fragment.ConstFrameIterator

Bases: pybind11_object

arrow(self: pyrosetta.rosetta.core.fragment.ConstFrameIterator) → pyrosetta.rosetta.core.fragment.Frame

C++: core::fragment::ConstFrameIterator::operator->() const –> class std::shared_ptr<const class core::fragment::Frame>

dereference(self: pyrosetta.rosetta.core.fragment.ConstFrameIterator) → pyrosetta.rosetta.core.fragment.Frame

C++: core::fragment::ConstFrameIterator::operator*() const –> class std::shared_ptr<const class core::fragment::Frame>

frame_ptr(self: pyrosetta.rosetta.core.fragment.ConstFrameIterator) → pyrosetta.rosetta.core.fragment.Frame

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

pre_increment(self: pyrosetta.rosetta.core.fragment.ConstFrameIterator) → pyrosetta.rosetta.core.fragment.ConstFrameIterator

C++: core::fragment::ConstFrameIterator::operator++() –> class core::fragment::ConstFrameIterator &

class pyrosetta.rosetta.core.fragment.ConstantLengthFragSet

Bases: 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

add(*args, **kwargs)

Overloaded function.

1. 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

2. 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

3. 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

4. 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.

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

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

2. 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.

1. read_fragment_file(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, filename: str) -> None

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

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

4. 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(std::string, unsigned long, unsigned long, bool) –> void

read_fragment_stream(*args, **kwargs)

Overloaded function.

1. read_fragment_stream(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, filename: str, first_line: str, data: pyrosetta.rosetta.std.istream) -> None

2. read_fragment_stream(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, filename: str, first_line: str, data: pyrosetta.rosetta.std.istream, top25: int) -> None

3. read_fragment_stream(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, filename: str, first_line: str, data: pyrosetta.rosetta.std.istream, top25: int, ncopies: int) -> None

4. read_fragment_stream(self: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, filename: str, first_line: str, data: pyrosetta.rosetta.std.istream, top25: int, ncopies: int, bAnnotation: bool) -> None

C++: core::fragment::ConstantLengthFragSet::read_fragment_stream(const std::string &, const std::string &, std::istream &, 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.ConstantLengthFragSetIterator_

Bases: FrameIteratorWorker_

class pyrosetta.rosetta.core.fragment.DownJumpSRFD

Bases: SingleResidueFragData

static _static_type_name() → str

C++: core::fragment::DownJumpSRFD::_static_type_name() –> std::string

apply(*args, **kwargs)

Overloaded function.

1. apply(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : pyrosetta.rosetta.core.pose.Pose, intra_frame_pos: int, : pyrosetta.rosetta.core.fragment.Frame) -> bool

the seq_pos is hijacked for the rt_nr

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

2. apply(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : core::kinematics::MoveMap, : pyrosetta.rosetta.core.pose.Pose, intra_frame_pos: int, : pyrosetta.rosetta.core.fragment.Frame) -> bool

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

3. apply(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : pyrosetta.rosetta.core.pose.Pose, : int) -> bool

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

4. apply(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : core::kinematics::MoveMap, : pyrosetta.rosetta.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

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

apply_ss(*args, **kwargs)

Overloaded function.

1. apply_ss(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : str, : int, : pyrosetta.rosetta.core.fragment.Frame) -> bool

C++: core::fragment::DownJumpSRFD::apply_ss(std::string &, unsigned long, const class core::fragment::Frame &) const –> bool

2. apply_ss(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : str, : int) -> bool

C++: core::fragment::DownJumpSRFD::apply_ss(std::string &, unsigned long) const –> bool

assign(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : pyrosetta.rosetta.core.fragment.DownJumpSRFD) → pyrosetta.rosetta.core.fragment.DownJumpSRFD

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

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

clone

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

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

create a new instance of this object

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

is_applicable(*args, **kwargs)

Overloaded function.

1. is_applicable(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : core::kinematics::MoveMap, pos: int, : pyrosetta.rosetta.core.fragment.Frame) -> bool

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

2. is_applicable(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : core::kinematics::MoveMap, : int) -> bool

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

is_compatible(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : pyrosetta.rosetta.core.fragment.SingleResidueFragData) → bool

C++: core::fragment::DownJumpSRFD::is_compatible(const class core::fragment::SingleResidueFragData &) const –> bool

read(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, in: pyrosetta.rosetta.std.istream) → None

C++: core::fragment::DownJumpSRFD::read(std::istream &) –> void

read_data(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : pyrosetta.rosetta.std.istream) → None

Default implementation: noop

C++: core::fragment::SingleResidueFragData::read_data(std::istream &) –> void

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

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

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

C++: core::fragment::SingleResidueFragData::sequence() const –> char

set_jump(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, setting: pyrosetta.rosetta.core.kinematics.RT) → None

set value of jump

C++: core::fragment::DownJumpSRFD::set_jump(class core::kinematics::RT) –> void

set_sequence(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, sequence: str) → None

C++: core::fragment::SingleResidueFragData::set_sequence(const char) –> void

set_standard_stub_atoms(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD) → None

C++: core::fragment::DownJumpSRFD::set_standard_stub_atoms() –> void

set_stub_atoms(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, downstream: pyrosetta.rosetta.utility.vector1_std_string, upstream: pyrosetta.rosetta.utility.vector1_std_string) → None

C++: core::fragment::DownJumpSRFD::set_stub_atoms(class utility::vector1<std::string, class std::allocator<std::string > >, class utility::vector1<std::string, class std::allocator<std::string > >) –> void

show(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::DownJumpSRFD::show(std::ostream &) const –> void

steal(*args, **kwargs)

Overloaded function.

1. steal(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : pyrosetta.rosetta.core.pose.Pose, pos: int, : pyrosetta.rosetta.core.fragment.Frame) -> bool

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

2. steal(self: pyrosetta.rosetta.core.fragment.DownJumpSRFD, : pyrosetta.rosetta.core.pose.Pose, : int) -> bool

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

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

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

class pyrosetta.rosetta.core.fragment.FragCache_protocols_simple_moves_GunnTuple_t

Bases: CacheWrapper_protocols_simple_moves_GunnTuple_core_fragment_MapCacheUnit_protocols_simple_moves_GunnTuple_t

assign(*args, **kwargs)

Overloaded function.

1. assign(self: pyrosetta.rosetta.core.fragment.FragCache_protocols_simple_moves_GunnTuple_t, : pyrosetta.rosetta.core.fragment.FragCache_protocols_simple_moves_GunnTuple_t) -> pyrosetta.rosetta.core.fragment.FragCache_protocols_simple_moves_GunnTuple_t

C++: core::fragment::FragCache<protocols::simple_moves::GunnTuple>::operator=(const class core::fragment::FragCache<struct protocols::simple_moves::GunnTuple> &) –> class core::fragment::FragCache<struct protocols::simple_moves::GunnTuple> &

2. assign(self: pyrosetta.rosetta.core.fragment.FragCache_protocols_simple_moves_GunnTuple_t, : pyrosetta.rosetta.core.fragment.CacheWrapper_protocols_simple_moves_GunnTuple_core_fragment_MapCacheUnit_protocols_simple_moves_GunnTuple_t) -> pyrosetta.rosetta.core.fragment.CacheWrapper_protocols_simple_moves_GunnTuple_core_fragment_MapCacheUnit_protocols_simple_moves_GunnTuple_t

C++: core::fragment::CacheWrapper<protocols::simple_moves::GunnTuple, core::fragment::MapCacheUnit<protocols::simple_moves::GunnTuple> >::operator=(const class core::fragment::CacheWrapper<struct protocols::simple_moves::GunnTuple, class core::fragment::MapCacheUnit<struct protocols::simple_moves::GunnTuple> > &) –> class core::fragment::CacheWrapper<struct protocols::simple_moves::GunnTuple, class core::fragment::MapCacheUnit<struct protocols::simple_moves::GunnTuple> > &

property new_cache_

store(*args, **kwargs)

Overloaded function.

1. store(self: pyrosetta.rosetta.core.fragment.FragCache_protocols_simple_moves_GunnTuple_t, frame: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, score: pyrosetta.rosetta.protocols.simple_moves.GunnTuple) -> None

C++: core::fragment::CacheWrapper<protocols::simple_moves::GunnTuple, core::fragment::MapCacheUnit<protocols::simple_moves::GunnTuple> >::store(const class core::fragment::Frame &, unsigned long, const struct protocols::simple_moves::GunnTuple &) –> void

2. store(self: pyrosetta.rosetta.core.fragment.FragCache_protocols_simple_moves_GunnTuple_t, frag_id: core::fragment::FragID, score: pyrosetta.rosetta.protocols.simple_moves.GunnTuple) -> None

C++: core::fragment::CacheWrapper<protocols::simple_moves::GunnTuple, core::fragment::MapCacheUnit<protocols::simple_moves::GunnTuple> >::store(const class core::fragment::FragID &, const struct protocols::simple_moves::GunnTuple &) –> void

property tag_

class pyrosetta.rosetta.core.fragment.FragData

Bases: pybind11_object

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.

1. apply(self: pyrosetta.rosetta.core.fragment.FragData, : core::kinematics::MoveMap, : pyrosetta.rosetta.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

2. apply(self: pyrosetta.rosetta.core.fragment.FragData, : core::kinematics::MoveMap, : pyrosetta.rosetta.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

3. apply(self: pyrosetta.rosetta.core.fragment.FragData, : pyrosetta.rosetta.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

4. apply(self: pyrosetta.rosetta.core.fragment.FragData, : pyrosetta.rosetta.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 &, std::string &, const class core::fragment::Frame &) const –> unsigned long

assign(self: pyrosetta.rosetta.core.fragment.FragData, : pyrosetta.rosetta.core.fragment.FragData) → pyrosetta.rosetta.core.fragment.FragData

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

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

Returns the chain if it has been specified, ‘_’ otherwise.

C++: core::fragment::FragData::chain() const –> char

clone(self: pyrosetta.rosetta.core.fragment.FragData) → pyrosetta.rosetta.core.fragment.FragData

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

copy(self: pyrosetta.rosetta.core.fragment.FragData, frag_data: pyrosetta.rosetta.core.fragment.FragData) → None

C++: core::fragment::FragData::copy(const class core::fragment::FragData &) –> void

generate_sub_fragment(self: pyrosetta.rosetta.core.fragment.FragData, start: int, stop: int) → pyrosetta.rosetta.core.fragment.FragData

C++: core::fragment::FragData::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.

1. 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

2. 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.FragData) → str

Returns the PDB identifier if it has been specified, “no_pdb” otherwise.

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

pdbpos(self: pyrosetta.rosetta.core.fragment.FragData) → int

C++: core::fragment::FragData::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.

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

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

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

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

sequence(*args, **kwargs)

Overloaded function.

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

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

2. 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.

1. set_valid(self: pyrosetta.rosetta.core.fragment.FragData) -> None

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

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

show(*args, **kwargs)

Overloaded function.

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

C++: core::fragment::FragData::show(std::ostream &) const –> void

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

C++: core::fragment::FragData::show(std::ostream &, 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(std::ostream &) const –> void

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

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

steal(*args, **kwargs)

Overloaded function.

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

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

2. steal(self: pyrosetta.rosetta.core.fragment.FragData, : pyrosetta.rosetta.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.FragFactory

Bases: pybind11_object

add_frag_type(self: pyrosetta.rosetta.core.fragment.FragFactory, type_name: str, frag_type: pyrosetta.rosetta.core.fragment.SingleResidueFragData) → None

C++: core::fragment::FragFactory::add_frag_type(const std::string &, class std::shared_ptr<class core::fragment::SingleResidueFragData>) –> void

add_frame_type(self: pyrosetta.rosetta.core.fragment.FragFactory, type_name: str, new_frag: pyrosetta.rosetta.core.fragment.Frame) → None

C++: core::fragment::FragFactory::add_frame_type(const std::string &, class std::shared_ptr<class core::fragment::Frame>) –> void

frag_type(self: pyrosetta.rosetta.core.fragment.FragFactory, frag_name: str) → pyrosetta.rosetta.core.fragment.SingleResidueFragData

C++: core::fragment::FragFactory::frag_type(const std::string &) const –> class std::shared_ptr<class core::fragment::SingleResidueFragData>

frame(self: pyrosetta.rosetta.core.fragment.FragFactory, frame_name: str) → pyrosetta.rosetta.core.fragment.Frame

C++: core::fragment::FragFactory::frame(const std::string &) const –> class std::shared_ptr<class core::fragment::Frame>

class pyrosetta.rosetta.core.fragment.FragID

Bases: pybind11_object

apply(*args, **kwargs)

Overloaded function.

1. apply(self: pyrosetta.rosetta.core.fragment.FragID, mm: pyrosetta.rosetta.core.kinematics.MoveMap, pose: pyrosetta.rosetta.core.pose.Pose) -> int

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

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

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

apply_ss(self: pyrosetta.rosetta.core.fragment.FragID, mm: pyrosetta.rosetta.core.kinematics.MoveMap, ss: str) → int

C++: core::fragment::FragID::apply_ss(const class core::kinematics::MoveMap &, std::string &) const –> unsigned long

assign(self: pyrosetta.rosetta.core.fragment.FragID, rhs: pyrosetta.rosetta.core.fragment.FragID) → pyrosetta.rosetta.core.fragment.FragID

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

property first

fragment(self: pyrosetta.rosetta.core.fragment.FragID) → pyrosetta.rosetta.core.fragment.FragData

C++: core::fragment::FragID::fragment() const –> const class core::fragment::FragData &

fragment_ptr(self: pyrosetta.rosetta.core.fragment.FragID) → pyrosetta.rosetta.core.fragment.FragData

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

frame(self: pyrosetta.rosetta.core.fragment.FragID) → pyrosetta.rosetta.core.fragment.Frame

C++: core::fragment::FragID::frame() const –> const class core::fragment::Frame &

frame_ptr(self: pyrosetta.rosetta.core.fragment.FragID) → pyrosetta.rosetta.core.fragment.Frame

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

id(self: pyrosetta.rosetta.core.fragment.FragID) → int

C++: core::fragment::FragID::id() const –> unsigned long

is_valid(self: pyrosetta.rosetta.core.fragment.FragID) → bool

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

property second

class pyrosetta.rosetta.core.fragment.FragID_Iterator

Bases: pybind11_object

arrow(self: pyrosetta.rosetta.core.fragment.FragID_Iterator) → pyrosetta.rosetta.core.fragment.FragID

C++: core::fragment::FragID_Iterator::operator->() –> class core::fragment::FragID *

dereference(self: pyrosetta.rosetta.core.fragment.FragID_Iterator) → pyrosetta.rosetta.core.fragment.FragID

C++: core::fragment::FragID_Iterator::operator*() –> class core::fragment::FragID

frag_id(self: pyrosetta.rosetta.core.fragment.FragID_Iterator) → pyrosetta.rosetta.core.fragment.FragID

C++: core::fragment::FragID_Iterator::frag_id() –> class core::fragment::FragID

pre_increment(self: pyrosetta.rosetta.core.fragment.FragID_Iterator) → pyrosetta.rosetta.core.fragment.FragID_Iterator

C++: core::fragment::FragID_Iterator::operator++() –> class core::fragment::FragID_Iterator &

class pyrosetta.rosetta.core.fragment.FragSet

Bases: pybind11_object

The FragSet: (Interface Definition – Virtual BaseClass )

add(*args, **kwargs)

Overloaded function.

1. 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

2. 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

3. 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

4. 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.

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

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

2. 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.FragSetCollection

Bases: FragSet

add(*args, **kwargs)

Overloaded function.

1. 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

2. 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

3. 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

4. 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

add_fragset(self: pyrosetta.rosetta.core.fragment.FragSetCollection, fragset: pyrosetta.rosetta.core.fragment.FragSet) → None

C++: core::fragment::FragSetCollection::add_fragset(class std::shared_ptr<class core::fragment::FragSet>) –> void

assign(self: pyrosetta.rosetta.core.fragment.FragSetCollection, : pyrosetta.rosetta.core.fragment.FragSetCollection) → pyrosetta.rosetta.core.fragment.FragSetCollection

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

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

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

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

C++: core::fragment::FragSetCollection::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.FragSetCollection) → bool

C++: core::fragment::FragSetCollection::empty() const –> bool

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

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

end(self: pyrosetta.rosetta.core.fragment.FragSetCollection) → core::fragment::ConstFrameIterator

C++: core::fragment::FragSetCollection::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.

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

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

2. 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.FragSetCollection) → core::fragment::FrameIterator

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

nonconst_end(self: pyrosetta.rosetta.core.fragment.FragSetCollection) → core::fragment::FrameIterator

C++: core::fragment::FragSetCollection::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.FragSetCollection, move_map: core::kinematics::MoveMap, start: int, end: int, min_overlap: int, min_length: int, frames: pyrosetta.rosetta.core.fragment.FrameList) → int

C++: core::fragment::FragSetCollection::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.FragmentIO

Bases: pybind11_object

clean_frag_cache(self: pyrosetta.rosetta.core.fragment.FragmentIO) → None

remove all FragSets that are not referenced outside the cache.

C++: core::fragment::FragmentIO::clean_frag_cache() –> void

get_frag_factory(self: pyrosetta.rosetta.core.fragment.FragmentIO) → pyrosetta.rosetta.core.fragment.FragFactory

C++: core::fragment::FragmentIO::get_frag_factory() –> class core::fragment::FragFactory &

read_data(self: pyrosetta.rosetta.core.fragment.FragmentIO, filename: str) → pyrosetta.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. NOTE that this is using global data and is thread unsafe and is evil.

C++: core::fragment::FragmentIO::read_data(const std::string &) –> class std::shared_ptr<class core::fragment::FragSet>

read_data_from_stream(self: pyrosetta.rosetta.core.fragment.FragmentIO, filename: str, data: pyrosetta.rosetta.std.istream) → pyrosetta.rosetta.core.fragment.FragSet

C++: core::fragment::FragmentIO::read_data_from_stream(const std::string &, std::istream &) –> class std::shared_ptr<class core::fragment::FragSet>

read_frames_from_file(self: pyrosetta.rosetta.core.fragment.FragmentIO, filename: str, : pyrosetta.rosetta.core.fragment.FrameList) → None

C++: core::fragment::FragmentIO::read_frames_from_file(const std::string &, class core::fragment::FrameList &) –> void

read_frames_from_stream(self: pyrosetta.rosetta.core.fragment.FragmentIO, filename: str, firstline: str, data: pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.fragment.FrameList) → None

C++: core::fragment::FragmentIO::read_frames_from_stream(const std::string &, const std::string &, std::istream &, class core::fragment::FrameList &) –> void

set_ncopies(self: pyrosetta.rosetta.core.fragment.FragmentIO, setting: int) → None

Updates the number of copies of each fragment to keep (default 1)

C++: core::fragment::FragmentIO::set_ncopies(unsigned long) –> void

set_read_annotation(*args, **kwargs)

Overloaded function.

1. set_read_annotation(self: pyrosetta.rosetta.core.fragment.FragmentIO) -> None

2. set_read_annotation(self: pyrosetta.rosetta.core.fragment.FragmentIO, setting: bool) -> None

Toggles between reading annotated (true) and non-annotated (false)

C++: core::fragment::FragmentIO::set_read_annotation(bool) –> void

set_top_frag_num(self: pyrosetta.rosetta.core.fragment.FragmentIO, setting: int) → None

Updates the number of distinct fragments to keep

C++: core::fragment::FragmentIO::set_top_frag_num(unsigned long) –> void

write_data(self: pyrosetta.rosetta.core.fragment.FragmentIO, file: str, frags: pyrosetta.rosetta.core.fragment.FragSet) → None

C++: core::fragment::FragmentIO::write_data(const std::string &, const class core::fragment::FragSet &) –> void

class pyrosetta.rosetta.core.fragment.FragmentRmsd

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.fragment.FragmentRmsd, : pyrosetta.rosetta.core.fragment.FragmentRmsd) → pyrosetta.rosetta.core.fragment.FragmentRmsd

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

fragment(self: pyrosetta.rosetta.core.fragment.FragmentRmsd, position: int, k: int) → pyrosetta.rosetta.core.fragment.FragData

Returns the kth fragment at the specified position

in the fragment library.

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

rmsd(self: pyrosetta.rosetta.core.fragment.FragmentRmsd, position: int, k: int, reference: pyrosetta.rosetta.core.pose.Pose) → float

Returns the RMSD of the kth fragment at the specified position

in the fragment library and pose.

C++: core::fragment::FragmentRmsd::rmsd(unsigned long, unsigned long, const class core::pose::Pose &) const –> double

class pyrosetta.rosetta.core.fragment.FragmentSetLoader

Bases: ResourceLoader

%FragmentSetLoader constructs a FragSet instance from data provided by the %ResourceManager.

assign(self: pyrosetta.rosetta.core.fragment.FragmentSetLoader, : pyrosetta.rosetta.core.fragment.FragmentSetLoader) → pyrosetta.rosetta.core.fragment.FragmentSetLoader

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

static classname() → str

C++: core::fragment::FragmentSetLoader::classname() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

C++: core::fragment::FragmentSetLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.core.fragment.FragmentSetLoaderCreator

Bases: ResourceLoaderCreator

%FragmentSetLoaderCreator allows the ResourceLoaderFactory to create a FragmentSetLoader instance, which in turn can load a FragmentSet.

The FragmentSetLoader class can be constructed from the string “FragmentSet”, which enables a user to specify that this type of %resource is required for a particular %job in their XML input file.

assign(self: pyrosetta.rosetta.core.fragment.FragmentSetLoaderCreator, : pyrosetta.rosetta.core.fragment.FragmentSetLoaderCreator) → pyrosetta.rosetta.core.fragment.FragmentSetLoaderCreator

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

create_resource_loader(self: pyrosetta.rosetta.core.fragment.FragmentSetLoaderCreator) → pyrosetta.rosetta.basic.resource_manager.ResourceLoader

Return a up-casted owning pointer (ResourceLoaderOP) to the resource loader.

C++: core::fragment::FragmentSetLoaderCreator::create_resource_loader() const –> class std::shared_ptr<class basic::resource_manager::ResourceLoader>

loader_type(self: pyrosetta.rosetta.core.fragment.FragmentSetLoaderCreator) → str

Return the string identifier for the associated ResourceLoader (FragmentSet).

C++: core::fragment::FragmentSetLoaderCreator::loader_type() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.core.fragment.FragmentSetLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: core::fragment::FragmentSetLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.core.fragment.Frame

Bases: 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

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.

static _static_type_name() → str

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

add_fragment(*args, **kwargs)

Overloaded function.

1. 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

2. 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.

1. apply(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap, frag_num: int, pose: pyrosetta.rosetta.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

2. apply(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, pose: pyrosetta.rosetta.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, std::string &) 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(std::string, 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: pyrosetta.rosetta.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.

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

2. 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(std::istream &) –> 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(std::ostream &) const –> void

show_classic(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::Frame::show_classic(std::ostream &) const –> void

show_header(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::Frame::show_header(std::ostream &) 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: pyrosetta.rosetta.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.FrameIterator

Bases: ConstFrameIterator

arrow(self: pyrosetta.rosetta.core.fragment.FrameIterator) → pyrosetta.rosetta.core.fragment.Frame

C++: core::fragment::FrameIterator::operator->() –> class std::shared_ptr<class core::fragment::Frame>

dereference(self: pyrosetta.rosetta.core.fragment.FrameIterator) → pyrosetta.rosetta.core.fragment.Frame

C++: core::fragment::FrameIterator::operator*() –> class std::shared_ptr<class core::fragment::Frame>

frame_ptr(self: pyrosetta.rosetta.core.fragment.FrameIterator) → pyrosetta.rosetta.core.fragment.Frame

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

pre_increment(self: pyrosetta.rosetta.core.fragment.FrameIterator) → pyrosetta.rosetta.core.fragment.FrameIterator

C++: core::fragment::FrameIterator::operator++() –> class core::fragment::FrameIterator &

class pyrosetta.rosetta.core.fragment.FrameIteratorWorker_

Bases: pybind11_object

class pyrosetta.rosetta.core.fragment.FrameList

Bases: vector1_std_shared_ptr_core_fragment_Frame_t

append(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, arg0: core::fragment::Frame) → None

adds an element to the end

assign(self: pyrosetta.rosetta.core.fragment.FrameList, : pyrosetta.rosetta.core.fragment.FrameList) → pyrosetta.rosetta.core.fragment.FrameList

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

back(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) → core::fragment::Frame

access the last element

capacity(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) → int

returns the number of elements that can be held in currently allocated storage

clear(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) → None

clears the contents

count(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, arg0: core::fragment::Frame) → int

counts the elements that are equal to value

erase(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, arg0: int) → None

erases element at index

extend(othervec)

flat_size(self: pyrosetta.rosetta.core.fragment.FrameList) → int

C++: core::fragment::FrameList::flat_size() const –> unsigned long

fragID(self: pyrosetta.rosetta.core.fragment.FrameList, flat_nr: int) → core::fragment::FragID

C++: core::fragment::FrameList::fragID(unsigned long) –> class core::fragment::FragID

frame_vector(self: pyrosetta.rosetta.core.fragment.FrameList) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t

C++: core::fragment::FrameList::frame_vector() –> class utility::vector1<class std::shared_ptr<class core::fragment::Frame>, class std::allocator<class std::shared_ptr<class core::fragment::Frame> > >

front(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) → core::fragment::Frame

access the first element

l(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) → int

lower index

max_size(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) → int

returns the maximum possible number of elements

pop(*args, **kwargs)

Overloaded function.

1. pop(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> core::fragment::Frame

remove and return last item

2. pop(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, arg0: int) -> core::fragment::Frame

remove and return item at index

remove(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, arg0: core::fragment::Frame) → None

Remove the first item from the list whose value is x. It is an error if there is no such item.

reserve(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, arg0: int) → None

reserves storage

resize(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, arg0: int) → None

changes the number of elements stored

shrink_to_fit(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) → None

reduces memory usage by freeing unused memory

u(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) → int

upper index

class pyrosetta.rosetta.core.fragment.FrameListIterator_

Bases: FrameIteratorWorker_

class pyrosetta.rosetta.core.fragment.IndependentBBTorsionSRFD

Bases: 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).

static _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: pyrosetta.rosetta.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(std::string &, 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(std::istream &) –> 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(std::ostream &) const –> void

steal(self: pyrosetta.rosetta.core.fragment.BBTorsionSRFD, : pyrosetta.rosetta.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: 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

static _static_type_name() → str

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

add_fragment(*args, **kwargs)

Overloaded function.

1. 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

2. 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.

1. apply(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap, frag_num: int, pose: pyrosetta.rosetta.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

2. apply(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, pose: pyrosetta.rosetta.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, std::string &) 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(std::string, 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>

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

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

2. 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.NonContinuousFrame) → bool

true if frame is continuous

C++: core::fragment::NonContinuousFrame::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.NonContinuousFrame, pos: int) → bool

C++: core::fragment::NonContinuousFrame::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.NonContinuousFrame, : pyrosetta.rosetta.std.istream) → None

C++: core::fragment::NonContinuousFrame::read(std::istream &) –> void

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

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

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

set_pos(self: pyrosetta.rosetta.core.fragment.NonContinuousFrame, intra_pos: int, setting: int) → None

assign sequence position or jump_nr to internal position pos

C++: core::fragment::NonContinuousFrame::set_pos(unsigned long, unsigned long) –> void

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

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

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

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

shift to new start position ( change end accordingly )

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

show(self: pyrosetta.rosetta.core.fragment.NonContinuousFrame, : pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::NonContinuousFrame::show(std::ostream &) const –> void

show_classic(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::Frame::show_classic(std::ostream &) const –> void

show_header(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::Frame::show_header(std::ostream &) 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: pyrosetta.rosetta.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.JumpingFrame) → str

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

class pyrosetta.rosetta.core.fragment.MinimalFragSet

Bases: FragSet

add(*args, **kwargs)

Overloaded function.

1. 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

2. 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

3. 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

4. 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.MinimalFragSet, : pyrosetta.rosetta.core.fragment.MinimalFragSet) → pyrosetta.rosetta.core.fragment.MinimalFragSet

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

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

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

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

C++: core::fragment::MinimalFragSet::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.MinimalFragSet) → bool

C++: core::fragment::MinimalFragSet::empty() const –> bool

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

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

end(self: pyrosetta.rosetta.core.fragment.MinimalFragSet) → pyrosetta.rosetta.core.fragment.ConstFrameIterator

C++: core::fragment::MinimalFragSet::end() const –> class core::fragment::ConstFrameIterator

frames(self: pyrosetta.rosetta.core.fragment.MinimalFragSet, pos: int, frames: pyrosetta.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.

C++: core::fragment::MinimalFragSet::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.

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

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

2. 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.MinimalFragSet) → pyrosetta.rosetta.core.fragment.FrameIterator

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

nonconst_end(self: pyrosetta.rosetta.core.fragment.MinimalFragSet) → pyrosetta.rosetta.core.fragment.FrameIterator

C++: core::fragment::MinimalFragSet::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

read_fragment_file(*args, **kwargs)

Overloaded function.

1. read_fragment_file(self: pyrosetta.rosetta.core.fragment.MinimalFragSet, filename: str) -> None

2. read_fragment_file(self: pyrosetta.rosetta.core.fragment.MinimalFragSet, filename: str, top25: int) -> None

3. read_fragment_file(self: pyrosetta.rosetta.core.fragment.MinimalFragSet, filename: str, top25: int, ncopies: int) -> None

C++: core::fragment::MinimalFragSet::read_fragment_file(std::string, unsigned long, unsigned long) –> void

read_fragment_stream(*args, **kwargs)

Overloaded function.

1. read_fragment_stream(self: pyrosetta.rosetta.core.fragment.MinimalFragSet, filename: str, first_line: str, data: pyrosetta.rosetta.std.istream) -> None

2. read_fragment_stream(self: pyrosetta.rosetta.core.fragment.MinimalFragSet, filename: str, first_line: str, data: pyrosetta.rosetta.std.istream, top25: int) -> None

3. read_fragment_stream(self: pyrosetta.rosetta.core.fragment.MinimalFragSet, filename: str, first_line: str, data: pyrosetta.rosetta.std.istream, top25: int, ncopies: int) -> None

C++: core::fragment::MinimalFragSet::read_fragment_stream(const std::string &, const std::string &, std::istream &, unsigned long, unsigned long) –> void

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

C++: core::fragment::MinimalFragSet::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.MinimalFragSetIterator_

Bases: FrameIteratorWorker_

class pyrosetta.rosetta.core.fragment.NonContinuousFrame

Bases: 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

static _static_type_name() → str

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

add_fragment(*args, **kwargs)

Overloaded function.

1. 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

2. 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.

1. apply(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap, frag_num: int, pose: pyrosetta.rosetta.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

2. apply(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, pose: pyrosetta.rosetta.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, std::string &) const –> unsigned long

assign(self: pyrosetta.rosetta.core.fragment.NonContinuousFrame, : pyrosetta.rosetta.core.fragment.NonContinuousFrame) → pyrosetta.rosetta.core.fragment.NonContinuousFrame

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

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(std::string, 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.NonContinuousFrame) → pyrosetta.rosetta.core.fragment.Frame

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

C++: core::fragment::NonContinuousFrame::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: pyrosetta.rosetta.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.

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

2. 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.NonContinuousFrame) → bool

true if frame is continuous

C++: core::fragment::NonContinuousFrame::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.NonContinuousFrame, pos: int) → bool

C++: core::fragment::NonContinuousFrame::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.NonContinuousFrame, : pyrosetta.rosetta.std.istream) → None

C++: core::fragment::NonContinuousFrame::read(std::istream &) –> void

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

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

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

set_pos(self: pyrosetta.rosetta.core.fragment.NonContinuousFrame, intra_pos: int, setting: int) → None

assign sequence position or jump_nr to internal position pos

C++: core::fragment::NonContinuousFrame::set_pos(unsigned long, unsigned long) –> void

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

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

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

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

shift to new start position ( change end accordingly )

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

show(self: pyrosetta.rosetta.core.fragment.NonContinuousFrame, : pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::NonContinuousFrame::show(std::ostream &) const –> void

show_classic(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::Frame::show_classic(std::ostream &) const –> void

show_header(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::Frame::show_header(std::ostream &) 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: pyrosetta.rosetta.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.OrderedFragSet

Bases: FragSet

add(*args, **kwargs)

Overloaded function.

1. 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

2. 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

3. 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

4. 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.OrderedFragSet, : pyrosetta.rosetta.core.fragment.OrderedFragSet) → pyrosetta.rosetta.core.fragment.OrderedFragSet

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

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

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

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

C++: core::fragment::OrderedFragSet::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.OrderedFragSet) → bool

C++: core::fragment::OrderedFragSet::empty() const –> bool

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

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

end(self: pyrosetta.rosetta.core.fragment.OrderedFragSet) → pyrosetta.rosetta.core.fragment.ConstFrameIterator

C++: core::fragment::OrderedFragSet::end() const –> class core::fragment::ConstFrameIterator

frames(self: pyrosetta.rosetta.core.fragment.OrderedFragSet, pos: int, frames: pyrosetta.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.

C++: core::fragment::OrderedFragSet::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.

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

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

2. 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.OrderedFragSet) → pyrosetta.rosetta.core.fragment.FrameIterator

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

nonconst_end(self: pyrosetta.rosetta.core.fragment.OrderedFragSet) → pyrosetta.rosetta.core.fragment.FrameIterator

C++: core::fragment::OrderedFragSet::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.OrderedFragSet, mm: core::kinematics::MoveMap, start: int, end: int, : int, : int, frames: pyrosetta.rosetta.core.fragment.FrameList) → int

C++: core::fragment::OrderedFragSet::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.OrderedFragSetIterator_

Bases: FrameIteratorWorker_

class pyrosetta.rosetta.core.fragment.SecondaryStructure

Bases: pybind11_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,

assign(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, : pyrosetta.rosetta.core.fragment.SecondaryStructure) → pyrosetta.rosetta.core.fragment.SecondaryStructure

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

confidence(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, pos: int) → float

confidence at position

C++: core::fragment::SecondaryStructure::confidence(unsigned long) const –> double

extend(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, : int) → None

extends with pure ‘L’ at end until requested size is reached.

C++: core::fragment::SecondaryStructure::extend(unsigned long) –> void

helix_fraction(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, pos: int) → float

helix fraction at position

C++: core::fragment::SecondaryStructure::helix_fraction(unsigned long) const –> double

loop_fraction(*args, **kwargs)

Overloaded function.

1. loop_fraction(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, pos: int) -> float

return loop fraction at position

C++: core::fragment::SecondaryStructure::loop_fraction(unsigned long) const –> double

2. loop_fraction(self: pyrosetta.rosetta.core.fragment.SecondaryStructure) -> pyrosetta.rosetta.ObjexxFCL.FArray1D_float_t

return loop fraction - FArray

C++: core::fragment::SecondaryStructure::loop_fraction() const –> const class ObjexxFCL::FArray1D<float> &

read_from_file(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, fn: str) → None

read from file

C++: core::fragment::SecondaryStructure::read_from_file(std::string) –> void

read_psipred_ss2(*args, **kwargs)

Overloaded function.

1. read_psipred_ss2(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, os: pyrosetta.rosetta.std.istream) -> None

write psipred format

C++: core::fragment::SecondaryStructure::read_psipred_ss2(std::istream &) –> void

2. read_psipred_ss2(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, filename: str) -> None

write psipred format

C++: core::fragment::SecondaryStructure::read_psipred_ss2(std::string) –> void

read_talos_ss(*args, **kwargs)

Overloaded function.

1. read_talos_ss(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, os: pyrosetta.rosetta.std.istream) -> None

read talos+ format

C++: core::fragment::SecondaryStructure::read_talos_ss(std::istream &) –> void

2. read_talos_ss(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, filename: str) -> None

read talos+ format

C++: core::fragment::SecondaryStructure::read_talos_ss(std::string) –> void

secstruct(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, pos: int) → str

returns the most probably secstruct at that position

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

set_fractions(*args, **kwargs)

Overloaded function.

1. set_fractions(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, pos: int, helix_fraction: float, sheet_fraction: float, loop_fraction: float) -> None

2. set_fractions(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, pos: int, helix_fraction: float, sheet_fraction: float, loop_fraction: float, confidence: float) -> None

sets secondary structure probabilities at a given position

C++: core::fragment::SecondaryStructure::set_fractions(unsigned long, double, double, double, double) –> void

sheet_fraction(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, pos: int) → float

alias for strand-fraction …

C++: core::fragment::SecondaryStructure::sheet_fraction(unsigned long) const –> double

show(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, : pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::SecondaryStructure::show(std::ostream &) const –> void

strand_fraction(*args, **kwargs)

Overloaded function.

1. strand_fraction(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, pos: int) -> float

return strand fraction at position

C++: core::fragment::SecondaryStructure::strand_fraction(unsigned long) const –> double

2. strand_fraction(self: pyrosetta.rosetta.core.fragment.SecondaryStructure) -> pyrosetta.rosetta.ObjexxFCL.FArray1D_float_t

return strand fraction - FArray

C++: core::fragment::SecondaryStructure::strand_fraction() const –> const class ObjexxFCL::FArray1D<float> &

total_residue(self: pyrosetta.rosetta.core.fragment.SecondaryStructure) → int

number of residues for which information is available

C++: core::fragment::SecondaryStructure::total_residue() const –> unsigned long

write_psipred_ss2(self: pyrosetta.rosetta.core.fragment.SecondaryStructure, os: pyrosetta.rosetta.std.ostream, sequence: str) → None

write psipred format

C++: core::fragment::SecondaryStructure::write_psipred_ss2(std::ostream &, const std::string &) const –> void

class pyrosetta.rosetta.core.fragment.SecstructSRFD

Bases: SingleResidueFragData

static _static_type_name() → str

C++: core::fragment::SecstructSRFD::_static_type_name() –> std::string

apply(*args, **kwargs)

Overloaded function.

1. apply(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, : pyrosetta.rosetta.core.pose.Pose, seq_pos: int) -> bool

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

2. apply(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, : core::kinematics::MoveMap, pose: pyrosetta.rosetta.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

C++: core::fragment::SecstructSRFD::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(std::string &, unsigned long) const –> bool

assign(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, : pyrosetta.rosetta.core.fragment.SecstructSRFD) → pyrosetta.rosetta.core.fragment.SecstructSRFD

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

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

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

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

create a new instance of this object

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

is_applicable(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, : core::kinematics::MoveMap, seq_pos: int) → bool

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

is_compatible(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, : pyrosetta.rosetta.core.fragment.SingleResidueFragData) → bool

C++: core::fragment::SecstructSRFD::is_compatible(const class core::fragment::SingleResidueFragData &) const –> bool

read_data(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, in: pyrosetta.rosetta.std.istream) → None

C++: core::fragment::SecstructSRFD::read_data(std::istream &) –> 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_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

show(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::SecstructSRFD::show(std::ostream &) const –> void

steal(self: pyrosetta.rosetta.core.fragment.SecstructSRFD, : pyrosetta.rosetta.core.pose.Pose, seq_pos: int) → bool

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

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

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

class pyrosetta.rosetta.core.fragment.SingleResidueFragData

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

static _static_type_name() → str

C++: core::fragment::SingleResidueFragData::_static_type_name() –> std::string

apply(*args, **kwargs)

Overloaded function.

1. apply(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : pyrosetta.rosetta.core.pose.Pose, seq_pos: int) -> bool

insert fragment_data into pose at position seq_pos

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

2. apply(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, movemap: core::kinematics::MoveMap, pose: pyrosetta.rosetta.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.

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

3. apply(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : pyrosetta.rosetta.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 );

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

4. apply(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, movemap: core::kinematics::MoveMap, pose: pyrosetta.rosetta.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

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

apply_ss(*args, **kwargs)

Overloaded function.

1. apply_ss(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : str, seq_pos: int) -> bool

insert fragment_data sec-struct into ss-string at position seq_pos

C++: core::fragment::SingleResidueFragData::apply_ss(std::string &, unsigned long) const –> bool

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

C++: core::fragment::SingleResidueFragData::apply_ss(std::string &, unsigned long, const class core::fragment::Frame &) const –> bool

assign(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : pyrosetta.rosetta.core.fragment.SingleResidueFragData) → pyrosetta.rosetta.core.fragment.SingleResidueFragData

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

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

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

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

create a new instance of this object

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

is_applicable(*args, **kwargs)

Overloaded function.

1. is_applicable(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : core::kinematics::MoveMap, intra_frame_pos: int, : core::fragment::Frame) -> bool

check weather dofs can be moved

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

2. is_applicable(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : core::kinematics::MoveMap, pos: int) -> bool

check whether dofs can be moved

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

is_compatible(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : pyrosetta.rosetta.core.fragment.SingleResidueFragData) → bool

check weather SRFD applies to same dofs and is of same type

C++: core::fragment::SingleResidueFragData::is_compatible(const class core::fragment::SingleResidueFragData &) const –> bool

read_data(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : pyrosetta.rosetta.std.istream) → None

Default implementation: noop

C++: core::fragment::SingleResidueFragData::read_data(std::istream &) –> void

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

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

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

C++: core::fragment::SingleResidueFragData::sequence() const –> char

set_sequence(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, sequence: str) → None

C++: core::fragment::SingleResidueFragData::set_sequence(const char) –> void

show(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::SingleResidueFragData::show(std::ostream &) const –> void

steal(*args, **kwargs)

Overloaded function.

1. steal(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : pyrosetta.rosetta.core.pose.Pose, seq_pos: int) -> bool

insert fragment_data into pose at position seq_pos

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

2. steal(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : pyrosetta.rosetta.core.pose.Pose, intra_frame_pos: int, : core::fragment::Frame) -> bool

insert fragment_data into pose at position seq_pos

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

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

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

class pyrosetta.rosetta.core.fragment.UpJumpSRFD

Bases: SingleResidueFragData

static _static_type_name() → str

C++: core::fragment::UpJumpSRFD::_static_type_name() –> std::string

apply(*args, **kwargs)

Overloaded function.

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

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

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

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

3. apply(self: pyrosetta.rosetta.core.fragment.UpJumpSRFD, : pyrosetta.rosetta.core.pose.Pose, : int) -> bool

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

4. apply(self: pyrosetta.rosetta.core.fragment.UpJumpSRFD, : core::kinematics::MoveMap, : pyrosetta.rosetta.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

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

apply_ss(*args, **kwargs)

Overloaded function.

1. apply_ss(self: pyrosetta.rosetta.core.fragment.UpJumpSRFD, : str, : int, : pyrosetta.rosetta.core.fragment.Frame) -> bool

C++: core::fragment::UpJumpSRFD::apply_ss(std::string &, unsigned long, const class core::fragment::Frame &) const –> bool

2. apply_ss(self: pyrosetta.rosetta.core.fragment.UpJumpSRFD, : str, : int) -> bool

C++: core::fragment::UpJumpSRFD::apply_ss(std::string &, unsigned long) const –> bool

assign(self: pyrosetta.rosetta.core.fragment.UpJumpSRFD, : pyrosetta.rosetta.core.fragment.UpJumpSRFD) → pyrosetta.rosetta.core.fragment.UpJumpSRFD

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

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

clone

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

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

create a new instance of this object

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

is_applicable(self: pyrosetta.rosetta.core.fragment.UpJumpSRFD, : core::kinematics::MoveMap, : int) → bool

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

is_compatible(self: pyrosetta.rosetta.core.fragment.UpJumpSRFD, : pyrosetta.rosetta.core.fragment.SingleResidueFragData) → bool

C++: core::fragment::UpJumpSRFD::is_compatible(const class core::fragment::SingleResidueFragData &) const –> bool

read_data(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, : pyrosetta.rosetta.std.istream) → None

Default implementation: noop

C++: core::fragment::SingleResidueFragData::read_data(std::istream &) –> void

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

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

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

C++: core::fragment::SingleResidueFragData::sequence() const –> char

set_sequence(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, sequence: str) → None

C++: core::fragment::SingleResidueFragData::set_sequence(const char) –> void

show(self: pyrosetta.rosetta.core.fragment.SingleResidueFragData, out: pyrosetta.rosetta.std.ostream) → None

C++: core::fragment::SingleResidueFragData::show(std::ostream &) const –> void

steal(*args, **kwargs)

Overloaded function.

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

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

2. steal(self: pyrosetta.rosetta.core.fragment.UpJumpSRFD, : pyrosetta.rosetta.core.pose.Pose, : int) -> bool

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

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

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

pyrosetta.rosetta.core.fragment.apply_best_scoring_fragdata(pose: pyrosetta.rosetta.core.pose.Pose, frame: pyrosetta.rosetta.core.fragment.Frame, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

goes through all frag_data in the frame and puts the

best scoring one into the pose, i.e. quenches the frame

C++: core::fragment::apply_best_scoring_fragdata(class core::pose::Pose &, const class core::fragment::Frame &, const class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.fragment.chop_fragments(source: pyrosetta.rosetta.core.fragment.FragSet, dest: pyrosetta.rosetta.core.fragment.FragSet) → None

Function for chopping the X-sized fragments in source into fragments that

go into N-sized fragments in dest. Sizes are encoded by the value of max_frag_length() in both source and dest.

C++: core::fragment::chop_fragments(class core::fragment::FragSet &, class core::fragment::FragSet &) –> void

pyrosetta.rosetta.core.fragment.compute_per_residue_coverage(frags: pyrosetta.rosetta.core.fragment.FragSet, nr_frags: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

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

pyrosetta.rosetta.core.fragment.dump_frames_as_pdb(*args, **kwargs)

Overloaded function.

1. dump_frames_as_pdb(pose: pyrosetta.rosetta.core.pose.Pose, frames: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, filename: str) -> None

2. dump_frames_as_pdb(pose: pyrosetta.rosetta.core.pose.Pose, frames: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, filename: str, start_frag: int) -> None

writes FragData in multimodel pdb format

start_tag can be used to only write a subset of the contained frag data

C++: core::fragment::dump_frames_as_pdb(const class core::pose::Pose &, const class utility::vector1<class std::shared_ptr<class core::fragment::Frame>, class std::allocator<class std::shared_ptr<class core::fragment::Frame> > > &, const std::string &, unsigned long) –> void

pyrosetta.rosetta.core.fragment.fill_template_frames_from_pdb(pose: pyrosetta.rosetta.core.pose.Pose, template_frames: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, filename: str) → bool

filling a frameset from a multimodel pdb file

returns true if no error occured

C++: core::fragment::fill_template_frames_from_pdb(const class core::pose::Pose &, const class utility::vector1<class std::shared_ptr<class core::fragment::Frame>, class std::allocator<class std::shared_ptr<class core::fragment::Frame> > > &, const std::string &) –> bool

pyrosetta.rosetta.core.fragment.fragment_set_slice(*args, **kwargs)

Overloaded function.

1. fragment_set_slice(fragset: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, min_res: int, max_res: int) -> None

C++: core::fragment::fragment_set_slice(class std::shared_ptr<class core::fragment::ConstantLengthFragSet> &, const unsigned long &, const unsigned long &) –> void

2. fragment_set_slice(fragset: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet, slice_res: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: core::fragment::fragment_set_slice(class std::shared_ptr<class core::fragment::ConstantLengthFragSet> &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

pyrosetta.rosetta.core.fragment.getxform(m1: pyrosetta.rosetta.numeric.xyzVector_double_t, m2: pyrosetta.rosetta.numeric.xyzVector_double_t, m3: pyrosetta.rosetta.numeric.xyzVector_double_t, f1: pyrosetta.rosetta.numeric.xyzVector_double_t, f2: pyrosetta.rosetta.numeric.xyzVector_double_t, f3: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.core.kinematics.Stub

C++: core::fragment::getxform(class numeric::xyzVector<double>, class numeric::xyzVector<double>, class numeric::xyzVector<double>, class numeric::xyzVector<double>, class numeric::xyzVector<double>, class numeric::xyzVector<double>) –> class core::kinematics::Stub

pyrosetta.rosetta.core.fragment.make_pose_from_frags(*args, **kwargs)

Overloaded function.

1. make_pose_from_frags(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, frags: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_fragment_FragData_t) -> None

2. make_pose_from_frags(pose: pyrosetta.rosetta.core.pose.Pose, sequence: str, frags: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_fragment_FragData_t, chains: bool) -> None

C++: core::fragment::make_pose_from_frags(class core::pose::Pose &, std::string, 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) –> void

pyrosetta.rosetta.core.fragment.make_simple_fold_tree_from_jump_frame(: pyrosetta.rosetta.core.fragment.Frame, total_residue: int, new_fold_tree: pyrosetta.rosetta.core.kinematics.FoldTree) → None

given a JumpFrame with Up and DownJumpSRFDs as LAST SRFDs this will make a fold-tree compatible with the

Frame… this is NOT GOOD for sampling, since it introduces cut-points outside of fragments later for sampling: one could probably write a routine that looks if it can move existing Jumps in Fold-tree to fit the FRAME … if not it returns failure…

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

pyrosetta.rosetta.core.fragment.merge_frags(*args, **kwargs)

Overloaded function.

1. merge_frags(good_frags: pyrosetta.rosetta.core.fragment.FragSet, filling: pyrosetta.rosetta.core.fragment.FragSet, min_nr_frags: int) -> pyrosetta.rosetta.core.fragment.FragSet

2. merge_frags(good_frags: pyrosetta.rosetta.core.fragment.FragSet, filling: pyrosetta.rosetta.core.fragment.FragSet, min_nr_frags: int, bRandom: bool) -> pyrosetta.rosetta.core.fragment.FragSet

C++: core::fragment::merge_frags(const class core::fragment::FragSet &, const class core::fragment::FragSet &, unsigned long, bool) –> class std::shared_ptr<class core::fragment::FragSet>

pyrosetta.rosetta.core.fragment.read_std_frags_from_cmd(fragset_large: pyrosetta.rosetta.core.fragment.FragSet, fragset_small: pyrosetta.rosetta.core.fragment.FragSet) → None

C++: core::fragment::read_std_frags_from_cmd(class std::shared_ptr<class core::fragment::FragSet> &, class std::shared_ptr<class core::fragment::FragSet> &) –> void

pyrosetta.rosetta.core.fragment.retain_top(k: int, fragments: pyrosetta.rosetta.core.fragment.FragSet) → None

Removes all but the top <k> fragments from <fragments>

C++: core::fragment::retain_top(unsigned long, class std::shared_ptr<class core::fragment::FragSet>) –> void

pyrosetta.rosetta.core.fragment.steal_constant_length_frag_set_from_pose(pose: pyrosetta.rosetta.core.pose.Pose, fragset: pyrosetta.rosetta.core.fragment.ConstantLengthFragSet) → None

C++: core::fragment::steal_constant_length_frag_set_from_pose(const class core::pose::Pose &, class core::fragment::ConstantLengthFragSet &) –> void

pyrosetta.rosetta.core.fragment.steal_frag_set_from_pose(*args, **kwargs)

Overloaded function.

1. steal_frag_set_from_pose(pose_in: pyrosetta.rosetta.core.pose.Pose, fragset: pyrosetta.rosetta.core.fragment.FragSet, frag_type: pyrosetta.rosetta.core.fragment.FragData) -> None

C++: core::fragment::steal_frag_set_from_pose(const class core::pose::Pose &, class core::fragment::FragSet &, class std::shared_ptr<const class core::fragment::FragData>) –> void

2. steal_frag_set_from_pose(pose_in: pyrosetta.rosetta.core.pose.Pose, begin: int, end: int, fragset: pyrosetta.rosetta.core.fragment.FragSet, frag_type: pyrosetta.rosetta.core.fragment.FragData) -> None

C++: core::fragment::steal_frag_set_from_pose(const class core::pose::Pose &, const unsigned long, const unsigned long, class core::fragment::FragSet &, class std::shared_ptr<const class core::fragment::FragData>) –> void

3. steal_frag_set_from_pose(pose_in: pyrosetta.rosetta.core.pose.Pose, fragset: pyrosetta.rosetta.core.fragment.FragSet, frag_type: pyrosetta.rosetta.core.fragment.FragData, active_residues: pyrosetta.rosetta.std.set_unsigned_long_t) -> None

C++: core::fragment::steal_frag_set_from_pose(const class core::pose::Pose &, class core::fragment::FragSet &, class std::shared_ptr<const class core::fragment::FragData>, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &) –> void

class pyrosetta.rosetta.core.fragment.torsions

Bases: pybind11_object

property aa

property omega

property phi

property psi

property ss

pyrosetta.rosetta.core.fragment.xform_pose(*args, **kwargs)

Overloaded function.

1. xform_pose(pose: pyrosetta.rosetta.core.pose.Pose, s: pyrosetta.rosetta.core.kinematics.Stub) -> None

2. xform_pose(pose: pyrosetta.rosetta.core.pose.Pose, s: pyrosetta.rosetta.core.kinematics.Stub, sres: int) -> None

3. xform_pose(pose: pyrosetta.rosetta.core.pose.Pose, s: pyrosetta.rosetta.core.kinematics.Stub, sres: int, eres: int) -> None

C++: core::fragment::xform_pose(class core::pose::Pose &, const class core::kinematics::Stub &, unsigned long, unsigned long) –> void