loops¶

Bindings for protocols::loops namespace

class pyrosetta.rosetta.protocols.loops.EXCN_Loop_not_closed¶

Bases: Exception

add_msg(self: pyrosetta.rosetta.utility.excn.Exception, str: str) → None¶: C++: utility::excn::Exception::add_msg(const std::string &) –> void

assign(self: pyrosetta.rosetta.protocols.loops.EXCN_Loop_not_closed, : pyrosetta.rosetta.protocols.loops.EXCN_Loop_not_closed) → pyrosetta.rosetta.protocols.loops.EXCN_Loop_not_closed¶: C++: protocols::loops::EXCN_Loop_not_closed::operator=(const class protocols::loops::EXCN_Loop_not_closed &) –> class protocols::loops::EXCN_Loop_not_closed &

crash_log(self: pyrosetta.rosetta.utility.excn.Exception) → None¶

Invoke a crash log for throwing this exception.: If your exception is one which is a “non-error” exception, override this function to do nothing.

C++: utility::excn::Exception::crash_log() const –> void

display(self: pyrosetta.rosetta.utility.excn.Exception) → None¶

Present this exception to the user.: Will invoke crash log reporting, if applicable

C++: utility::excn::Exception::display() const –> void

file(self: pyrosetta.rosetta.utility.excn.Exception) → str¶: C++: utility::excn::Exception::file() –> const std::string &

line(self: pyrosetta.rosetta.utility.excn.Exception) → int¶: C++: utility::excn::Exception::line() –> int

msg(*args, **kwargs)¶

Overloaded function.

msg(self: pyrosetta.rosetta.utility.excn.Exception) -> str

Will return a formatted message (with file/line information)

C++: utility::excn::Exception::msg() const –> std::string

msg(self: pyrosetta.rosetta.utility.excn.Exception, m: str) -> None

Will set the raw message.

C++: utility::excn::Exception::msg(const std::string &) –> void

prepend_to_msg(self: pyrosetta.rosetta.utility.excn.Exception, str: str) → None¶: C++: utility::excn::Exception::prepend_to_msg(const std::string &) –> void

raw_msg(self: pyrosetta.rosetta.utility.excn.Exception) → str¶

Will return the raw message (without file/line information)

C++: utility::excn::Exception::raw_msg() const –> std::string

show(self: pyrosetta.rosetta.utility.excn.Exception, : pyrosetta.rosetta.std.ostream) → None¶: C++: utility::excn::Exception::show(std::ostream &) const –> void

traceback(self: pyrosetta.rosetta.utility.excn.Exception) → str¶: C++: utility::excn::Exception::traceback() –> const std::string &

what(self: pyrosetta.rosetta.std.exception) → str¶: C++: std::exception::what() const –> const char *

class pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops¶

Bases: Mover

add_cutpoint_variants(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops, add_cp_variants: bool) → None¶

Add cutpoint variants that are used for scoring with chainbreak term?: default false

C++: protocols::loops::FoldTreeFromLoops::add_cutpoint_variants(bool) –> void

apply(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::loops::FoldTreeFromLoops::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops, : pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops) → pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops¶: C++: protocols::loops::FoldTreeFromLoops::operator=(const class protocols::loops::FoldTreeFromLoops &) –> class protocols::loops::FoldTreeFromLoops &

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None¶

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

clone(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::loops::FoldTreeFromLoops::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

create(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

fresh_instance(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::loops::FoldTreeFromLoops::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_additional_output(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

C++: protocols::moves::Mover::get_additional_output() –> class std::shared_ptr<class core::pose::Pose>

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob¶: C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

get_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶

A tag is a unique identifier used to identify structures produced: by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

C++: protocols::moves::Mover::get_current_tag() const –> std::string

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_last_move_status(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.MoverStatus¶

returns status after an apply(). The job distributor (august 08 vintage) will check this function to see if your protocol wants to filter its results - if your protocol wants to say “that run was no good, skip it” then use the protected last_move_status(MoverStatus) to change the value that this function will return.

C++: protocols::moves::Mover::get_last_move_status() const –> enum protocols::moves::MoverStatus

get_name(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops) → str¶: C++: protocols::loops::FoldTreeFromLoops::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t¶: C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶: C++: protocols::moves::Mover::get_type() const –> std::string

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_t¶

non-const accessor

C++: protocols::moves::Mover::info() –> class std::list<std::string, class std::allocator<std::string > > &

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

loops(*args, **kwargs)¶

Overloaded function.

loops(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops, l: pyrosetta.rosetta.protocols.loops.Loops) -> None

Manually set the loops to be used.

C++: protocols::loops::FoldTreeFromLoops::loops(const class std::shared_ptr<class protocols::loops::Loops>) –> void

loops(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.loops.Loops

Not a getter - will compute the loops to be used with the passed pose.

C++: protocols::loops::FoldTreeFromLoops::loops(const class core::pose::Pose &) const –> class std::shared_ptr<class protocols::loops::Loops>

static mover_name() → str¶: C++: protocols::loops::FoldTreeFromLoops::mover_name() –> std::string

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoops, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::loops::FoldTreeFromLoops::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::loops::FoldTreeFromLoops::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static register_options() → None¶

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool¶

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on: each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool¶

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input: pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None¶

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None¶: C++: protocols::moves::Mover::set_current_tag(const std::string &) –> void

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None¶

Set the ‘type’ string

C++: protocols::moves::Mover::set_type(const std::string &) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(std::ostream &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

: Unit test support function. Apply one move to a given pose.: Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)¶

Overloaded function.

type(self: pyrosetta.rosetta.protocols.moves.Mover, type_in: str) -> None

Set the ‘type’ string

C++: protocols::moves::Mover::type(const std::string &) –> void

type(self: pyrosetta.rosetta.protocols.moves.Mover) -> str

Get the set ‘type’ string

C++: protocols::moves::Mover::type() const –> const std::string &

class pyrosetta.rosetta.protocols.loops.FoldTreeFromLoopsCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoopsCreator, : pyrosetta.rosetta.protocols.loops.FoldTreeFromLoopsCreator) → pyrosetta.rosetta.protocols.loops.FoldTreeFromLoopsCreator¶: C++: protocols::loops::FoldTreeFromLoopsCreator::operator=(const class protocols::loops::FoldTreeFromLoopsCreator &) –> class protocols::loops::FoldTreeFromLoopsCreator &

create_mover(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoopsCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::loops::FoldTreeFromLoopsCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoopsCreator) → str¶: C++: protocols::loops::FoldTreeFromLoopsCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.loops.FoldTreeFromLoopsCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::loops::FoldTreeFromLoopsCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile¶

Bases: pybind11_object

This class ensures that the Loops object that is needed to run any of the various forms of loop modeling is correctly initialized from a Pose. If the residues specified from a loops file have not been resolved into the residue indices for a Pose, then this class will die with an assertion failure.

assign(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile, rhs: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile) → pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile¶

assignment operator; takes it’s “in charge” state from rhs

C++: protocols::loops::GuardedLoopsFromFile::operator=(const class protocols::loops::GuardedLoopsFromFile &) –> class protocols::loops::GuardedLoopsFromFile &

in_charge(*args, **kwargs)¶

Overloaded function.

in_charge(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile, setting: bool) -> None

set to “in charge” state.

C++: protocols::loops::GuardedLoopsFromFile::in_charge(bool) –> void

in_charge(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile) -> bool

get “in charge” state.

C++: protocols::loops::GuardedLoopsFromFile::in_charge() const –> bool

loops(*args, **kwargs)¶

Overloaded function.

loops(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile) -> pyrosetta.rosetta.protocols.loops.Loops

request the LoopsOP pointer; asserts that the loop indices: have been resolved or that “I am not in charge”.

C++: protocols::loops::GuardedLoopsFromFile::loops() –> class std::shared_ptr<class protocols::loops::Loops>

loops(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile, setting: pyrosetta.rosetta.protocols.loops.Loops) -> None

set the loops to copy the contents of settings into the existing Loops object

C++: protocols::loops::GuardedLoopsFromFile::loops(const class protocols::loops::Loops &) –> void

loops(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile, setting: pyrosetta.rosetta.protocols.loops.LoopsFileData) -> None

set the LoopsFileData object directly

C++: protocols::loops::GuardedLoopsFromFile::loops(const class protocols::loops::LoopsFileData &) –> void

loops(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile, setting: protocols::loops::loops_definers::LoopsDefiner) -> None

set the LoopsDefiner object directly

C++: protocols::loops::GuardedLoopsFromFile::loops(const class std::shared_ptr<class protocols::loops::loops_definers::LoopsDefiner> &) –> void

loops_definer(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile) → protocols::loops::loops_definers::LoopsDefiner¶: C++: protocols::loops::GuardedLoopsFromFile::loops_definer() const –> class std::shared_ptr<const class protocols::loops::loops_definers::LoopsDefiner>

loops_file_data(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile) → pyrosetta.rosetta.protocols.loops.LoopsFileData¶

read access to the LoopsFileData

C++: protocols::loops::GuardedLoopsFromFile::loops_file_data() const –> class std::shared_ptr<const class protocols::loops::LoopsFileData>

resolve_loop_indices(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile, : pyrosetta.rosetta.core.pose.Pose) → None¶

Resolve the loop indices, and mark the state as resolved, so that calls to loops() will succeed.: This function will re-resolve loop indices with a new pose, which may be important if the same loop_file_data_ is being applied to a pose which has different PDB indices. If I am not in charge, this is a no-op.

C++: protocols::loops::GuardedLoopsFromFile::resolve_loop_indices(const class core::pose::Pose &) –> void

resolve_loop_indices_once(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile, : pyrosetta.rosetta.core.pose.Pose) → None¶

/: Resolve the loop indices if they have not yet been resolved. If I am not in charge, this is a no-op.

C++: protocols::loops::GuardedLoopsFromFile::resolve_loop_indices_once(const class core::pose::Pose &) –> void

set_loops_pointer(self: pyrosetta.rosetta.protocols.loops.GuardedLoopsFromFile, setting: pyrosetta.rosetta.protocols.loops.Loops) → None¶

set the loops owning pointer object directly

C++: protocols::loops::GuardedLoopsFromFile::set_loops_pointer(class std::shared_ptr<class protocols::loops::Loops>) –> void

class pyrosetta.rosetta.protocols.loops.JSONFormattedLoopsFileReader¶

Bases: pybind11_object

read_loop_file(self: pyrosetta.rosetta.protocols.loops.JSONFormattedLoopsFileReader, is: pyrosetta.rosetta.std.istream, filename: str, prohibit_single_residue_loops: bool) → pyrosetta.rosetta.protocols.loops.LoopsFileData¶: C++: protocols::loops::JSONFormattedLoopsFileReader::read_loop_file(std::istream &, const std::string &, bool) –> class std::shared_ptr<class protocols::loops::LoopsFileData>

set_linecount_offset(self: pyrosetta.rosetta.protocols.loops.JSONFormattedLoopsFileReader, : int) → None¶

if the input stream has had some number of lines already removed from it,: indicate how many.

C++: protocols::loops::JSONFormattedLoopsFileReader::set_linecount_offset(unsigned long) –> void

class pyrosetta.rosetta.protocols.loops.Loop¶

Bases: pybind11_object

single loop definition

assign(self: pyrosetta.rosetta.protocols.loops.Loop, : pyrosetta.rosetta.protocols.loops.Loop) → pyrosetta.rosetta.protocols.loops.Loop¶: C++: protocols::loops::Loop::operator=(const class protocols::loops::Loop &) –> class protocols::loops::Loop &

auto_choose_cutpoint(self: pyrosetta.rosetta.protocols.loops.Loop, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Autochoose a cutpoint using the secondary structure of the pose: unless cutpoint is already set

C++: protocols::loops::Loop::auto_choose_cutpoint(const class core::pose::Pose &) –> void

choose_cutpoint(self: pyrosetta.rosetta.protocols.loops.Loop, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::loops::Loop::choose_cutpoint(const class core::pose::Pose &) –> void

cut(self: pyrosetta.rosetta.protocols.loops.Loop) → int¶: C++: protocols::loops::Loop::cut() const –> unsigned long

decreasing(self: pyrosetta.rosetta.protocols.loops.Loop) → bool¶

Returns true if the loop’s elements are decreasing

C++: protocols::loops::Loop::decreasing() const –> bool

get_residues(self: pyrosetta.rosetta.protocols.loops.Loop, selection: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶

add all residues within this loop definition into selection

C++: protocols::loops::Loop::get_residues(class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> void

increasing(self: pyrosetta.rosetta.protocols.loops.Loop) → bool¶

Returns true if the loop’s elements are increasing

C++: protocols::loops::Loop::increasing() const –> bool

is_extended(self: pyrosetta.rosetta.protocols.loops.Loop) → bool¶: C++: protocols::loops::Loop::is_extended() const –> bool

is_terminal(self: pyrosetta.rosetta.protocols.loops.Loop, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::loops::Loop::is_terminal(const class core::pose::Pose &) const –> bool

length(self: pyrosetta.rosetta.protocols.loops.Loop) → int¶

Assuming that the loop represents a contiguous stretch of residues,: returns the length. Makes no assumptions about directionality. That is, Loop(3,8).length() == Loop(8,3).length(). Constant time procedure.

C++: protocols::loops::Loop::length() const –> unsigned long

midpoint(self: pyrosetta.rosetta.protocols.loops.Loop) → int¶

Returns the midpoint of the loop

C++: protocols::loops::Loop::midpoint() const –> unsigned long

set_cut(self: pyrosetta.rosetta.protocols.loops.Loop, input: int) → None¶: C++: protocols::loops::Loop::set_cut(unsigned long) –> void

set_extended(self: pyrosetta.rosetta.protocols.loops.Loop, input: bool) → None¶: C++: protocols::loops::Loop::set_extended(bool) –> void

set_start(self: pyrosetta.rosetta.protocols.loops.Loop, input: int) → None¶: C++: protocols::loops::Loop::set_start(unsigned long) –> void

set_stop(self: pyrosetta.rosetta.protocols.loops.Loop, input: int) → None¶: C++: protocols::loops::Loop::set_stop(unsigned long) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.loops.Loop) -> None
show(self: pyrosetta.rosetta.protocols.loops.Loop, output: pyrosetta.rosetta.std.ostream) -> None

Generate a string representation of Loop

C++: protocols::loops::Loop::show(std::ostream &) const –> void

size(self: pyrosetta.rosetta.protocols.loops.Loop) → int¶: C++: protocols::loops::Loop::size() const –> unsigned long

skip_rate(self: pyrosetta.rosetta.protocols.loops.Loop) → float¶: C++: protocols::loops::Loop::skip_rate() const –> double

start(self: pyrosetta.rosetta.protocols.loops.Loop) → int¶: C++: protocols::loops::Loop::start() const –> unsigned long

stop(self: pyrosetta.rosetta.protocols.loops.Loop) → int¶: C++: protocols::loops::Loop::stop() const –> unsigned long

switch_movemap(*args, **kwargs)¶

Overloaded function.

switch_movemap(self: pyrosetta.rosetta.protocols.loops.Loop, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, : pyrosetta.rosetta.core.id.TorsionType) -> None
switch_movemap(self: pyrosetta.rosetta.protocols.loops.Loop, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, : pyrosetta.rosetta.core.id.TorsionType, allow_moves: bool) -> None

switch DOF_Type for residues in loop. id::CHI, id::BB — don’t: use with id::JUMP

C++: protocols::loops::Loop::switch_movemap(class core::kinematics::MoveMap &, enum core::id::TorsionType, bool) const –> void

class pyrosetta.rosetta.protocols.loops.LoopConfiguration¶

Bases: pybind11_object

Members:

extras

resSeq

iCode

chainID

skip_rate

extend

use_pose_numbering

number_of_configuration_keywords

chainID = <LoopConfiguration.chainID: 7>¶

extend = <LoopConfiguration.extend: 9>¶

extras = <LoopConfiguration.extras: 4>¶

iCode = <LoopConfiguration.iCode: 6>¶

property name¶

number_of_configuration_keywords = <LoopConfiguration.use_pose_numbering: 10>¶

resSeq = <LoopConfiguration.resSeq: 5>¶

skip_rate = <LoopConfiguration.skip_rate: 8>¶

use_pose_numbering = <LoopConfiguration.use_pose_numbering: 10>¶

property value¶

class pyrosetta.rosetta.protocols.loops.LoopFromFileData¶

Bases: pybind11_object

cutpoint_res(*args, **kwargs)¶

Overloaded function.

cutpoint_res(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData) -> pyrosetta.rosetta.core.pose.ResidueIndexDescription

C++: protocols::loops::LoopFromFileData::cutpoint_res() const –> class std::shared_ptr<const class core::pose::ResidueIndexDescription>

cutpoint_res(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData, setting: pyrosetta.rosetta.core.pose.ResidueIndexDescription) -> None

C++: protocols::loops::LoopFromFileData::cutpoint_res(class std::shared_ptr<const class core::pose::ResidueIndexDescription>) –> void

end_res(*args, **kwargs)¶

Overloaded function.

end_res(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData) -> pyrosetta.rosetta.core.pose.ResidueIndexDescription

C++: protocols::loops::LoopFromFileData::end_res() const –> class std::shared_ptr<const class core::pose::ResidueIndexDescription>

end_res(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData, setting: pyrosetta.rosetta.core.pose.ResidueIndexDescription) -> None

C++: protocols::loops::LoopFromFileData::end_res(class std::shared_ptr<const class core::pose::ResidueIndexDescription>) –> void

extended(*args, **kwargs)¶

Overloaded function.

extended(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData) -> bool

C++: protocols::loops::LoopFromFileData::extended() const –> bool

extended(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData, setting: bool) -> None

C++: protocols::loops::LoopFromFileData::extended(bool) –> void

prohibit_single_residue_loops(*args, **kwargs)¶

Overloaded function.

prohibit_single_residue_loops(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData) -> bool

C++: protocols::loops::LoopFromFileData::prohibit_single_residue_loops() const –> bool

prohibit_single_residue_loops(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData, setting: bool) -> None

C++: protocols::loops::LoopFromFileData::prohibit_single_residue_loops(bool) –> void

resolve_as_serialized_loop_from_pose(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.loops.SerializedLoop¶

loop-index resolution function: construct a SerializedLoopData object: by possibly retrieving data from a Pose. This function also performs the loop-index checks performed by the PoseNumberedLoopFileReader.

C++: protocols::loops::LoopFromFileData::resolve_as_serialized_loop_from_pose(const class core::pose::Pose &) const –> struct protocols::loops::SerializedLoop

skip_rate(*args, **kwargs)¶

Overloaded function.

skip_rate(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData) -> float

C++: protocols::loops::LoopFromFileData::skip_rate() const –> double

skip_rate(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData, setting: float) -> None

C++: protocols::loops::LoopFromFileData::skip_rate(double) –> void

start_res(*args, **kwargs)¶

Overloaded function.

start_res(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData) -> pyrosetta.rosetta.core.pose.ResidueIndexDescription

C++: protocols::loops::LoopFromFileData::start_res() const –> class std::shared_ptr<const class core::pose::ResidueIndexDescription>

start_res(self: pyrosetta.rosetta.protocols.loops.LoopFromFileData, setting: pyrosetta.rosetta.core.pose.ResidueIndexDescription) -> None

C++: protocols::loops::LoopFromFileData::start_res(class std::shared_ptr<const class core::pose::ResidueIndexDescription>) –> void

class pyrosetta.rosetta.protocols.loops.LoopMoverFactory¶

Bases: SingletonBase_protocols_loops_LoopMoverFactory_t

Create LoopMover Reporters

create_loop_mover(*args, **kwargs)¶

Overloaded function.

create_loop_mover(self: pyrosetta.rosetta.protocols.loops.LoopMoverFactory, type_name: str, loops: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.protocols.loops.loop_mover.LoopMover

Create a loop mover giving it a pointer to a loops object.: This loop mover will not be in charge of resolving loop indices.

C++: protocols::loops::LoopMoverFactory::create_loop_mover(const std::string &, const class std::shared_ptr<class protocols::loops::Loops>) –> class std::shared_ptr<class protocols::loops::loop_mover::LoopMover>

create_loop_mover(self: pyrosetta.rosetta.protocols.loops.LoopMoverFactory, type_name: str, loops: protocols::loops::LoopsFileData) -> pyrosetta.rosetta.protocols.loops.loop_mover.LoopMover

Create a loop mover giving it a pointer to a loops object.: This loop mover WILL be in charge of resolving loop indices.

C++: protocols::loops::LoopMoverFactory::create_loop_mover(const std::string &, const class protocols::loops::LoopsFileData &) –> class std::shared_ptr<class protocols::loops::loop_mover::LoopMover>

create_loop_mover(self: pyrosetta.rosetta.protocols.loops.LoopMoverFactory, type_name: str, guarded_loops: protocols::loops::GuardedLoopsFromFile) -> pyrosetta.rosetta.protocols.loops.loop_mover.LoopMover

Create a loop mover giving it a pointer to a GuardedLoopsFromFile object.: This loop mover WILL be in charge of resolving loop indices, unless, of course, the GuardedLoopsFromFile object in the pointer resolves the indices through some other Mover’s call to its resolve_loop_indices function.

C++: protocols::loops::LoopMoverFactory::create_loop_mover(const std::string &, class std::shared_ptr<class protocols::loops::GuardedLoopsFromFile>) –> class std::shared_ptr<class protocols::loops::loop_mover::LoopMover>

static get_instance() → protocols::loops::LoopMoverFactory¶: C++: utility::SingletonBase<protocols::loops::LoopMoverFactory>::get_instance() –> class protocols::loops::LoopMoverFactory *

class pyrosetta.rosetta.protocols.loops.Loop_lt¶

Bases: pybind11_object

used to sort Loops by start-res

class pyrosetta.rosetta.protocols.loops.Loops¶

Bases: pybind11_object

add_loop(*args, **kwargs)¶

Overloaded function.

add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, loop: protocols::loops::Loop) -> None
add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, loop: protocols::loops::Loop, minimal_gap: int) -> None

C++: protocols::loops::Loops::add_loop(class protocols::loops::Loop, unsigned long) –> void

add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int) -> None
add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int, cut: int) -> None
add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int, cut: int, skip_rate: float) -> None
add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int, cut: int, skip_rate: float, extended: bool) -> None

C++: protocols::loops::Loops::add_loop(const unsigned long, const unsigned long, const unsigned long, double, const bool) –> void

add_overlap_loop(*args, **kwargs)¶

Overloaded function.

add_overlap_loop(self: pyrosetta.rosetta.protocols.loops.Loops, loops: pyrosetta.rosetta.protocols.loops.Loops) -> None

C++: protocols::loops::Loops::add_overlap_loop(class protocols::loops::Loops) –> void

add_overlap_loop(self: pyrosetta.rosetta.protocols.loops.Loops, loop: protocols::loops::Loop) -> None

C++: protocols::loops::Loops::add_overlap_loop(const class protocols::loops::Loop &) –> void

assign(self: pyrosetta.rosetta.protocols.loops.Loops, src: pyrosetta.rosetta.protocols.loops.Loops) → pyrosetta.rosetta.protocols.loops.Loops¶: C++: protocols::loops::Loops::operator=(const class protocols::loops::Loops &) –> class protocols::loops::Loops &

auto_choose_cutpoints(self: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::loops::Loops::auto_choose_cutpoints(const class core::pose::Pose &) –> void

center_of_mass(self: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose, center: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶

Computes the center of mass of the Ca atoms specified by this

instance, writing the result to <center>. Assumes there is no missing backbone density.

Note: if this method is called on an instance without any Loop’s, returns (0,0,0).

C++: protocols::loops::Loops::center_of_mass(const class core::pose::Pose &, class numeric::xyzVector<double> *) const –> void

choose_cutpoints(self: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::loops::Loops::choose_cutpoints(const class core::pose::Pose &) –> void

clear(self: pyrosetta.rosetta.protocols.loops.Loops) → None¶: C++: protocols::loops::Loops::clear() –> void

clone(self: pyrosetta.rosetta.protocols.loops.Loops) → pyrosetta.rosetta.protocols.loops.Loops¶: C++: protocols::loops::Loops::clone() const –> class std::shared_ptr<class protocols::loops::Loops>

delete_loop(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int) → None¶: C++: protocols::loops::Loops::delete_loop(const unsigned long, const unsigned long) –> void

empty(self: pyrosetta.rosetta.protocols.loops.Loops) → bool¶: C++: protocols::loops::Loops::empty() const –> bool

file_reading_token(self: pyrosetta.rosetta.protocols.loops.Loops) → str¶: C++: protocols::loops::Loops::file_reading_token() –> const std::string &

static get_loop_file_reader() → protocols::loops::LoopsFileIO¶

Convenience function for creating a (stateless!) class that is able: to read in loops files in several different formats.

C++: protocols::loops::Loops::get_loop_file_reader() –> class std::shared_ptr<class protocols::loops::LoopsFileIO>

get_residues(self: pyrosetta.rosetta.protocols.loops.Loops, selection: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶

add all residues within this loop definition into selection

C++: protocols::loops::Loops::get_residues(class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> void

grow_all_loops(*args, **kwargs)¶

Overloaded function.

grow_all_loops(self: pyrosetta.rosetta.protocols.loops.Loops, nres: int, magnitude: float) -> None

Extend a loop

C++: protocols::loops::Loops::grow_all_loops(unsigned long, double) –> void

grow_all_loops(self: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose, magnitude: float) -> None

Extend a loop (don’t extend across cutpoints)

C++: protocols::loops::Loops::grow_all_loops(const class core::pose::Pose &, double) –> void

grow_loop(*args, **kwargs)¶

Overloaded function.

grow_loop(self: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose, loop: protocols::loops::Loop, magnitude: float) -> None

Extend a loop (don’t extend across cutpoints)

C++: protocols::loops::Loops::grow_loop(const class core::pose::Pose &, class protocols::loops::Loop &, double) –> void

grow_loop(self: pyrosetta.rosetta.protocols.loops.Loops, nres: int, loop: protocols::loops::Loop, magnitude: float) -> None

Extend a loop

C++: protocols::loops::Loops::grow_loop(unsigned long, class protocols::loops::Loop &, double) –> void

grow_loop(self: pyrosetta.rosetta.protocols.loops.Loops, nres: int, loop: protocols::loops::Loop, mag_left: float, mag_right: float) -> None

Extend a loop unequally in both dirs

C++: protocols::loops::Loops::grow_loop(unsigned long, class protocols::loops::Loop &, double, double) –> void

grow_loop_away_from_sheets(self: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose, loop: protocols::loops::Loop, magnitude: float) → None¶

if possible grows loop will not cross cutpoints or if possible into sheets

C++: protocols::loops::Loops::grow_loop_away_from_sheets(const class core::pose::Pose &, class protocols::loops::Loop &, double) –> void

has(*args, **kwargs)¶

Overloaded function.

has(self: pyrosetta.rosetta.protocols.loops.Loops, seqpos: int) -> bool
has(self: pyrosetta.rosetta.protocols.loops.Loops, seqpos: int, offset: int) -> bool

is seqpos a residue in this Loops container ?

C++: protocols::loops::Loops::has(const unsigned long, const int) const –> bool

invert(self: pyrosetta.rosetta.protocols.loops.Loops, num_residues: int) → pyrosetta.rosetta.protocols.loops.Loops¶

Given the total number of residues, returns the inverse of this selection.

C++: protocols::loops::Loops::invert(unsigned long) const –> class protocols::loops::Loops

is_loop_residue(*args, **kwargs)¶

Overloaded function.

is_loop_residue(self: pyrosetta.rosetta.protocols.loops.Loops, seqpos: int) -> bool
is_loop_residue(self: pyrosetta.rosetta.protocols.loops.Loops, seqpos: int, offset: int) -> bool

Is seqpos contained in any of my loops?

C++: protocols::loops::Loops::is_loop_residue(const unsigned long, const int) const –> bool

loop_file_name(self: pyrosetta.rosetta.protocols.loops.Loops) → str¶: C++: protocols::loops::Loops::loop_file_name() –> const std::string &

loop_index_of_residue(self: pyrosetta.rosetta.protocols.loops.Loops, seqpos: int) → int¶: C++: protocols::loops::Loops::loop_index_of_residue(const unsigned long) const –> unsigned long

loop_of_residue(self: pyrosetta.rosetta.protocols.loops.Loops, seqpos: int, loop: protocols::loops::Loop) → bool¶

yield the Loop which contains the residue seqpos, returns false if seqpos is not in any residue.

C++: protocols::loops::Loops::loop_of_residue(const unsigned long, class protocols::loops::Loop &) const –> bool

loop_size(*args, **kwargs)¶

Overloaded function.

loop_size(self: pyrosetta.rosetta.protocols.loops.Loops, loop_num: int) -> int

C++: protocols::loops::Loops::loop_size(const unsigned long) const –> unsigned long

loop_size(self: pyrosetta.rosetta.protocols.loops.Loops) -> int

return number of residues in all loops of this definition – sum_i( loop_size( i ) )

C++: protocols::loops::Loops::loop_size() const –> unsigned long

loops(self: pyrosetta.rosetta.protocols.loops.Loops) → pyrosetta.rosetta.utility.vector1_protocols_loops_Loop¶: C++: protocols::loops::Loops::loops() const –> const class utility::vector1<class protocols::loops::Loop, class std::allocator<class protocols::loops::Loop> > &

make_sequence_shift(self: pyrosetta.rosetta.protocols.loops.Loops, shift: int) → None¶: C++: protocols::loops::Loops::make_sequence_shift(int) –> void

nr_residues(self: pyrosetta.rosetta.protocols.loops.Loops) → int¶: C++: protocols::loops::Loops::nr_residues() const –> unsigned long

num_loop(self: pyrosetta.rosetta.protocols.loops.Loops) → int¶: C++: protocols::loops::Loops::num_loop() const –> unsigned long

push_back(*args, **kwargs)¶

Overloaded function.

push_back(self: pyrosetta.rosetta.protocols.loops.Loops, loop: protocols::loops::Loop) -> None

C++: protocols::loops::Loops::push_back(class protocols::loops::Loop) –> void

push_back(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int) -> None
push_back(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int, cut: int) -> None
push_back(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int, cut: int, skip_rate: float) -> None
push_back(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int, cut: int, skip_rate: float, extended: bool) -> None

C++: protocols::loops::Loops::push_back(const unsigned long, const unsigned long, const unsigned long, double, const bool) –> void

read_loops_options(self: pyrosetta.rosetta.protocols.loops.Loops) → None¶: C++: protocols::loops::Loops::read_loops_options() –> void

remove_terminal_loops(self: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::loops::Loops::remove_terminal_loops(const class core::pose::Pose &) –> void

sequential_order(self: pyrosetta.rosetta.protocols.loops.Loops) → None¶: C++: protocols::loops::Loops::sequential_order() –> void

set_extended(self: pyrosetta.rosetta.protocols.loops.Loops, input: bool) → None¶: C++: protocols::loops::Loops::set_extended(bool) –> void

set_file_reading_token(self: pyrosetta.rosetta.protocols.loops.Loops, token: str) → None¶: C++: protocols::loops::Loops::set_file_reading_token(const std::string &) –> void

set_loop_file_name_and_reset(self: pyrosetta.rosetta.protocols.loops.Loops, loop_filename: str) → None¶: C++: protocols::loops::Loops::set_loop_file_name_and_reset(const std::string &) –> void

set_strict_looprelax_checks(self: pyrosetta.rosetta.protocols.loops.Loops, check: bool) → None¶: C++: protocols::loops::Loops::set_strict_looprelax_checks(const bool) –> void

size(self: pyrosetta.rosetta.protocols.loops.Loops) → int¶: C++: protocols::loops::Loops::size() const –> unsigned long

strict_looprelax_checks(self: pyrosetta.rosetta.protocols.loops.Loops) → bool¶: C++: protocols::loops::Loops::strict_looprelax_checks() –> bool

switch_movemap(*args, **kwargs)¶

Overloaded function.

switch_movemap(self: pyrosetta.rosetta.protocols.loops.Loops, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, : pyrosetta.rosetta.core.id.TorsionType) -> None
switch_movemap(self: pyrosetta.rosetta.protocols.loops.Loops, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, : pyrosetta.rosetta.core.id.TorsionType, allow_moves: bool) -> None

C++: protocols::loops::Loops::switch_movemap(class core::kinematics::MoveMap &, enum core::id::TorsionType, bool) const –> void

verify_against(self: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::loops::Loops::verify_against(const class core::pose::Pose &) const –> void

write_loops_to_file(*args, **kwargs)¶

Overloaded function.

write_loops_to_file(self: pyrosetta.rosetta.protocols.loops.Loops, filename: str) -> None
write_loops_to_file(self: pyrosetta.rosetta.protocols.loops.Loops, filename: str, token: str) -> None

C++: protocols::loops::Loops::write_loops_to_file(const std::string &, std::string) const –> void

write_loops_to_stream(self: pyrosetta.rosetta.protocols.loops.Loops, data: pyrosetta.rosetta.std.ostream, token: str) → None¶: C++: protocols::loops::Loops::write_loops_to_stream(std::ostream &, std::string) const –> void

class pyrosetta.rosetta.protocols.loops.LoopsFileData¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.loops.LoopsFileData, : pyrosetta.rosetta.protocols.loops.LoopsFileData) → pyrosetta.rosetta.protocols.loops.LoopsFileData¶: C++: protocols::loops::LoopsFileData::operator=(const class protocols::loops::LoopsFileData &) –> class protocols::loops::LoopsFileData &

insert_loop_at_index(self: pyrosetta.rosetta.protocols.loops.LoopsFileData, loop: pyrosetta.rosetta.protocols.loops.LoopFromFileData, i: int) → None¶: C++: protocols::loops::LoopsFileData::insert_loop_at_index(const class protocols::loops::LoopFromFileData &, unsigned long) –> void

push_back(self: pyrosetta.rosetta.protocols.loops.LoopsFileData, loop: pyrosetta.rosetta.protocols.loops.LoopFromFileData) → None¶: C++: protocols::loops::LoopsFileData::push_back(const class protocols::loops::LoopFromFileData &) –> void

resize(self: pyrosetta.rosetta.protocols.loops.LoopsFileData, new_size: int) → None¶: C++: protocols::loops::LoopsFileData::resize(unsigned long) –> void

resolve_as_serialized_loops(self: pyrosetta.rosetta.protocols.loops.LoopsFileData, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_protocols_loops_SerializedLoop¶: C++: protocols::loops::LoopsFileData::resolve_as_serialized_loops(const class core::pose::Pose &) const –> class utility::vector1<struct protocols::loops::SerializedLoop, class std::allocator<struct protocols::loops::SerializedLoop> >

resolve_loops(self: pyrosetta.rosetta.protocols.loops.LoopsFileData, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.loops.Loops¶: C++: protocols::loops::LoopsFileData::resolve_loops(const class core::pose::Pose &) const –> class std::shared_ptr<class protocols::loops::Loops>

size(self: pyrosetta.rosetta.protocols.loops.LoopsFileData) → int¶: C++: protocols::loops::LoopsFileData::size() const –> unsigned long

class pyrosetta.rosetta.protocols.loops.LoopsFileIO¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.loops.LoopsFileIO, : pyrosetta.rosetta.protocols.loops.LoopsFileIO) → pyrosetta.rosetta.protocols.loops.LoopsFileIO¶: C++: protocols::loops::LoopsFileIO::operator=(const class protocols::loops::LoopsFileIO &) –> class protocols::loops::LoopsFileIO &

read_loop_file(*args, **kwargs)¶

Overloaded function.

read_loop_file(self: pyrosetta.rosetta.protocols.loops.LoopsFileIO, filename: str) -> pyrosetta.rosetta.protocols.loops.LoopsFileData
read_loop_file(self: pyrosetta.rosetta.protocols.loops.LoopsFileIO, filename: str, prohibit_single_residue_loops: bool) -> pyrosetta.rosetta.protocols.loops.LoopsFileData

Return an “unresolved” list of loops specified in a file: which can be turned into a “resolved” list of residue indices in a particular Pose by giving each LoopFromFileData object access to that Pose. Note: prohibit_single_residue_loops used to be called “strict_looprelax_checks_” which was decidedly opaque

C++: protocols::loops::LoopsFileIO::read_loop_file(const std::string &, bool) –> class std::shared_ptr<class protocols::loops::LoopsFileData>

read_loop_file_stream(*args, **kwargs)¶

Overloaded function.

read_loop_file_stream(self: pyrosetta.rosetta.protocols.loops.LoopsFileIO, loopfstream: pyrosetta.rosetta.std.istream, filename: str) -> pyrosetta.rosetta.protocols.loops.LoopsFileData
read_loop_file_stream(self: pyrosetta.rosetta.protocols.loops.LoopsFileIO, loopfstream: pyrosetta.rosetta.std.istream, filename: str, prohibit_single_residue_loops: bool) -> pyrosetta.rosetta.protocols.loops.LoopsFileData

C++: protocols::loops::LoopsFileIO::read_loop_file_stream(std::istream &, const std::string &, bool) –> class std::shared_ptr<class protocols::loops::LoopsFileData>

class pyrosetta.rosetta.protocols.loops.LoopsFileLoader¶

Bases: ResourceLoader

%LoopsFileLoader constructs a LoopsFileData instance from data provided by the %ResourceManager.

The %LoopsFileLoader is given an istream containing the information in a %LoopsFile from the ResourceManager. This information is then processed by an instance of LoopsFileIO to produce a LoopsFileDataOP to return to the protocol.

assign(self: pyrosetta.rosetta.protocols.loops.LoopsFileLoader, : pyrosetta.rosetta.protocols.loops.LoopsFileLoader) → pyrosetta.rosetta.protocols.loops.LoopsFileLoader¶: C++: protocols::loops::LoopsFileLoader::operator=(const class protocols::loops::LoopsFileLoader &) –> class protocols::loops::LoopsFileLoader &

static classname() → str¶: C++: protocols::loops::LoopsFileLoader::classname() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::loops::LoopsFileLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.loops.LoopsFileLoaderCreator¶

Bases: ResourceLoaderCreator

%LoopsFileLoaderCreator allows the ResourceLoaderFactory to create a LoopsFileLoader instance.

The LoopsFileLoader class can be constructed from the string “LoopsFile”, 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.protocols.loops.LoopsFileLoaderCreator, : pyrosetta.rosetta.protocols.loops.LoopsFileLoaderCreator) → pyrosetta.rosetta.protocols.loops.LoopsFileLoaderCreator¶: C++: protocols::loops::LoopsFileLoaderCreator::operator=(const class protocols::loops::LoopsFileLoaderCreator &) –> class protocols::loops::LoopsFileLoaderCreator &

create_resource_loader(self: pyrosetta.rosetta.protocols.loops.LoopsFileLoaderCreator) → pyrosetta.rosetta.basic.resource_manager.ResourceLoader¶

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

C++: protocols::loops::LoopsFileLoaderCreator::create_resource_loader() const –> class std::shared_ptr<class basic::resource_manager::ResourceLoader>

loader_type(self: pyrosetta.rosetta.protocols.loops.LoopsFileLoaderCreator) → str¶

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

C++: protocols::loops::LoopsFileLoaderCreator::loader_type() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.loops.LoopsFileLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::loops::LoopsFileLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.loops.PoseNumberedLoopFileReader¶

Bases: pybind11_object

This is the main legacy loop-reading function, which will read the pose-numbered file. This functionality is used by a great many number of places often having nothing to do with representing a loop, so it will persist.

assign(self: pyrosetta.rosetta.protocols.loops.PoseNumberedLoopFileReader, : pyrosetta.rosetta.protocols.loops.PoseNumberedLoopFileReader) → pyrosetta.rosetta.protocols.loops.PoseNumberedLoopFileReader¶: C++: protocols::loops::PoseNumberedLoopFileReader::operator=(const class protocols::loops::PoseNumberedLoopFileReader &) –> class protocols::loops::PoseNumberedLoopFileReader &

hijack_loop_reading_code_set_loop_line_begin_token(self: pyrosetta.rosetta.protocols.loops.PoseNumberedLoopFileReader, token: str) → None¶

For code that relys on reading loop-file-formatted ranges if residues: but which really ought to use

C++: protocols::loops::PoseNumberedLoopFileReader::hijack_loop_reading_code_set_loop_line_begin_token(const std::string &) –> void

read_pose_numbered_loops_file(*args, **kwargs)¶

Overloaded function.

read_pose_numbered_loops_file(self: pyrosetta.rosetta.protocols.loops.PoseNumberedLoopFileReader, is: pyrosetta.rosetta.std.istream, filename: str) -> pyrosetta.rosetta.utility.vector1_protocols_loops_SerializedLoop
read_pose_numbered_loops_file(self: pyrosetta.rosetta.protocols.loops.PoseNumberedLoopFileReader, is: pyrosetta.rosetta.std.istream, filename: str, strict_looprelax_checks: bool) -> pyrosetta.rosetta.utility.vector1_protocols_loops_SerializedLoop

C++: protocols::loops::PoseNumberedLoopFileReader::read_pose_numbered_loops_file(std::istream &, const std::string &, bool) –> class utility::vector1<struct protocols::loops::SerializedLoop, class std::allocator<struct protocols::loops::SerializedLoop> >

set_linecount_offset(self: pyrosetta.rosetta.protocols.loops.PoseNumberedLoopFileReader, : int) → None¶

if the input stream has had some number of lines already removed from it,: indicate how many.

C++: protocols::loops::PoseNumberedLoopFileReader::set_linecount_offset(unsigned long) –> void

class pyrosetta.rosetta.protocols.loops.RationalLoopComparator¶

Bases: pybind11_object

Orders loops by start position

class pyrosetta.rosetta.protocols.loops.ResidueIdentifier¶

Bases: pybind11_object

The following enumerators are used for parsing JSON formatted loop files

Members:

start

stop

cut_point

number_of_residue_identifiers

cut_point = <ResidueIdentifier.cut_point: 3>¶

property name¶

number_of_residue_identifiers = <ResidueIdentifier.cut_point: 3>¶

start = <ResidueIdentifier.start: 1>¶

stop = <ResidueIdentifier.stop: 2>¶

property value¶

class pyrosetta.rosetta.protocols.loops.SerializedLoop¶

Bases: pybind11_object

Bare-bones representation of a loop

property cut¶

property extended¶

property skip_rate¶

property start¶

property stop¶

pyrosetta.rosetta.protocols.loops.addScoresForLoopParts(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, native_pose: pyrosetta.rosetta.core.pose.Pose, nloops: int) → None¶: C++: protocols::loops::addScoresForLoopParts(class core::pose::Pose &, class protocols::loops::Loops, const class core::scoring::ScoreFunction &, class core::pose::Pose &, unsigned long) –> void

pyrosetta.rosetta.protocols.loops.add_coordinate_constraints_to_pose(pose: pyrosetta.rosetta.core.pose.Pose, constraint_target_pose: pyrosetta.rosetta.core.pose.Pose, exclude_regions: pyrosetta.rosetta.protocols.loops.Loops) → None¶: C++: protocols::loops::add_coordinate_constraints_to_pose(class core::pose::Pose &, const class core::pose::Pose &, class protocols::loops::Loops &) –> void

pyrosetta.rosetta.protocols.loops.add_cutpoint_variants(pose: pyrosetta.rosetta.core.pose.Pose) → None¶: Add cutpoint variants to all the cutpoints in a Pose.

C++: protocols::loops::add_cutpoint_variants(class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.loops.add_loop_flank_residues_bb_to_movemap(*args, **kwargs)¶

Overloaded function.

add_loop_flank_residues_bb_to_movemap(loops: pyrosetta.rosetta.protocols.loops.Loops, mm: pyrosetta.rosetta.core.kinematics.MoveMap) -> None
add_loop_flank_residues_bb_to_movemap(loops: pyrosetta.rosetta.protocols.loops.Loops, mm: pyrosetta.rosetta.core.kinematics.MoveMap, flank_size: int) -> None

add flank stem residues to the loop movemap

C++: protocols::loops::add_loop_flank_residues_bb_to_movemap(const class protocols::loops::Loops &, class core::kinematics::MoveMap &, unsigned long) –> void

pyrosetta.rosetta.protocols.loops.add_single_cutpoint_variant(*args, **kwargs)¶

Overloaded function.

add_single_cutpoint_variant(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) -> None

Add cutpoint variants around a single cutpoint (defined by a Loop).

C++: protocols::loops::add_single_cutpoint_variant(class core::pose::Pose &, const class protocols::loops::Loop &) –> void

add_single_cutpoint_variant(pose: pyrosetta.rosetta.core.pose.Pose, cutpoint: int) -> None

Add cutpoint variants around a single cutpoint (defined by residue number).

C++: protocols::loops::add_single_cutpoint_variant(class core::pose::Pose &, const unsigned long) –> void

pyrosetta.rosetta.protocols.loops.apply_sequence_mapping(pose: pyrosetta.rosetta.core.pose.Pose, target_seq: str, start_mapping: pyrosetta.rosetta.core.id.SequenceMapping) → None¶: C++: protocols::loops::apply_sequence_mapping(class core::pose::Pose &, const std::string &, const class core::id::SequenceMapping &) –> void

pyrosetta.rosetta.protocols.loops.ccd_close_loops(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None¶

close loops by the CCD mechanism

C++: protocols::loops::ccd_close_loops(class core::pose::Pose &, const class protocols::loops::Loops &, const class core::kinematics::MoveMap &) –> void

pyrosetta.rosetta.protocols.loops.compute_ss_regions(max_loop_frac: float, min_length: int, ss: pyrosetta.rosetta.core.fragment.SecondaryStructure) → pyrosetta.rosetta.protocols.loops.Loops¶: C++: protocols::loops::compute_ss_regions(double, unsigned long, const class core::fragment::SecondaryStructure &) –> class protocols::loops::Loops

pyrosetta.rosetta.protocols.loops.deep_copy(source: protocols::loops::Loops) → protocols::loops::Loops¶: C++: protocols::loops::deep_copy(const class protocols::loops::Loops &) –> class std::shared_ptr<class protocols::loops::Loops>

pyrosetta.rosetta.protocols.loops.define_scorable_core_from_secondary_structure(: pyrosetta.rosetta.core.fragment.SecondaryStructure, score_core: pyrosetta.rosetta.protocols.loops.Loops) → None¶: C++: protocols::loops::define_scorable_core_from_secondary_structure(const class core::fragment::SecondaryStructure &, class protocols::loops::Loops &) –> void

pyrosetta.rosetta.protocols.loops.extend_sequence_mapping(pose: pyrosetta.rosetta.core.pose.Pose, mapping: pyrosetta.rosetta.core.id.SequenceMapping, source_seq: str, target_seq: str) → None¶: C++: protocols::loops::extend_sequence_mapping(const class core::pose::Pose &, class core::id::SequenceMapping &, std::string &, std::string &) –> void

pyrosetta.rosetta.protocols.loops.extract_continuous_chunks(*args, **kwargs)¶

Overloaded function.

extract_continuous_chunks(pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.loops.Loops
extract_continuous_chunks(pose: pyrosetta.rosetta.core.pose.Pose, minimum_size: int) -> pyrosetta.rosetta.protocols.loops.Loops
extract_continuous_chunks(pose: pyrosetta.rosetta.core.pose.Pose, minimum_size: int, CA_CA_distance_cutoff: float) -> pyrosetta.rosetta.protocols.loops.Loops

C++: protocols::loops::extract_continuous_chunks(const class core::pose::Pose &, const unsigned long, const double) –> class protocols::loops::Loops

pyrosetta.rosetta.protocols.loops.extract_secondary_structure_chunks(*args, **kwargs)¶

Overloaded function.

extract_secondary_structure_chunks(pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.loops.Loops
extract_secondary_structure_chunks(pose: pyrosetta.rosetta.core.pose.Pose, extracted_ss_types: str) -> pyrosetta.rosetta.protocols.loops.Loops
extract_secondary_structure_chunks(pose: pyrosetta.rosetta.core.pose.Pose, extracted_ss_types: str, gap_size: int) -> pyrosetta.rosetta.protocols.loops.Loops
extract_secondary_structure_chunks(pose: pyrosetta.rosetta.core.pose.Pose, extracted_ss_types: str, gap_size: int, minimum_length_of_chunk_helix: int) -> pyrosetta.rosetta.protocols.loops.Loops
extract_secondary_structure_chunks(pose: pyrosetta.rosetta.core.pose.Pose, extracted_ss_types: str, gap_size: int, minimum_length_of_chunk_helix: int, minimum_length_of_chunk_strand: int) -> pyrosetta.rosetta.protocols.loops.Loops
extract_secondary_structure_chunks(pose: pyrosetta.rosetta.core.pose.Pose, extracted_ss_types: str, gap_size: int, minimum_length_of_chunk_helix: int, minimum_length_of_chunk_strand: int, minimum_length_of_chunk_loop: int) -> pyrosetta.rosetta.protocols.loops.Loops
extract_secondary_structure_chunks(pose: pyrosetta.rosetta.core.pose.Pose, extracted_ss_types: str, gap_size: int, minimum_length_of_chunk_helix: int, minimum_length_of_chunk_strand: int, minimum_length_of_chunk_loop: int, CA_CA_distance_cutoff: float) -> pyrosetta.rosetta.protocols.loops.Loops

Extract secondary structure chunks from the pose, using multiple secondary structure types: this function requires that the pose object already have secstruct information to get this information from structure (DSSP), call protocols::jumping::Dssp dssp_obj( *pose ); dssp_obj.insert_ss_into_pose( *pose ); or from secondary structure prediction (psipred_ss2 file), call core::pose::read_psipred_ss2_file(pose);

C++: protocols::loops::extract_secondary_structure_chunks(const class core::pose::Pose &, std::string, unsigned long, unsigned long, unsigned long, unsigned long, double) –> class protocols::loops::Loops

extract_secondary_structure_chunks(pose: pyrosetta.rosetta.core.pose.Pose, extracted_ss_type: str) -> pyrosetta.rosetta.protocols.loops.Loops

Extract secondary structure chunks from the pose, using a given secondary structure type

C++: protocols::loops::extract_secondary_structure_chunks(const class core::pose::Pose &, const char) –> class protocols::loops::Loops

pyrosetta.rosetta.protocols.loops.filter_loop_neighbors_by_distance(pose: pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.utility.vector1_bool, loops: pyrosetta.rosetta.protocols.loops.Loops, dist_cutoff: float) → None¶

filter set of loop neighbors to a certain CB distance: Takes distance from selection to neighbors to trim neighbors.

C++: protocols::loops::filter_loop_neighbors_by_distance(const class core::pose::Pose &, class utility::vector1<bool, class std::allocator<bool> > &, const class protocols::loops::Loops &, double &) –> void

pyrosetta.rosetta.protocols.loops.find_non_protein_chunks(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.loops.Loops¶: C++: protocols::loops::find_non_protein_chunks(const class core::pose::Pose &) –> class protocols::loops::Loops

pyrosetta.rosetta.protocols.loops.fix_with_coord_cst(rigid: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose, bCstAllAtom: bool, : pyrosetta.rosetta.utility.vector1_double) → None¶: C++: protocols::loops::fix_with_coord_cst(const class protocols::loops::Loops &, class core::pose::Pose &, bool, class utility::vector1<double, class std::allocator<double> > &) –> void

pyrosetta.rosetta.protocols.loops.fold_tree_from_loops(*args, **kwargs)¶

Overloaded function.

fold_tree_from_loops(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, f: pyrosetta.rosetta.core.kinematics.FoldTree) -> None
fold_tree_from_loops(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, f: pyrosetta.rosetta.core.kinematics.FoldTree, terminal_cutpoint: bool) -> None

construct a fold tree from loop definition

C++: protocols::loops::fold_tree_from_loops(const class core::pose::Pose &, const class protocols::loops::Loops &, class core::kinematics::FoldTree &, bool) –> void

pyrosetta.rosetta.protocols.loops.get_cen_scorefxn() → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::loops::get_cen_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.loops.get_fa_scorefxn() → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::loops::get_fa_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.loops.has_severe_pep_bond_geom_issues(*args, **kwargs)¶

Overloaded function.

has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, check_bonds: bool) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, check_bonds: bool, check_angles: bool) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, check_bonds: bool, check_angles: bool, max_c_n_dis: float) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, check_bonds: bool, check_angles: bool, max_c_n_dis: float, allowed_ca_c_n_deviation: float) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, check_bonds: bool, check_angles: bool, max_c_n_dis: float, allowed_ca_c_n_deviation: float, allowed_c_n_ca_deviation: float) -> Tuple[bool, int]

Measures C-N distance and N-Ca-C, C-N-CA bond angles to detect chainbreak/poory resolved loop residues if outside cutoff.

Returns boolean and the position of found wonky peptide bond (0 if none found). Does not use AtomTree to get angles/lengths, assumes resnum is connected to resnum +1

Values are based on the CDL. No peptide bond without severe chainbreaks or missing residues should have values: out of this range. -JAB Berkholz DS, Shapovalov MV, Dunbrack RL Jr, Karplus PA (2009) Conformation dependence of backbone geometry in proteins. Structure 17: 1316-1325. deviation is +/- from the min/max values of the CDL.

cutoffs are: 1.5, 15, 15

Jared Adolf-Bryfogle (jadolfbr.com)

C++: protocols::loops::has_severe_pep_bond_geom_issues(const class core::pose::Pose &, const class protocols::loops::Loop &, bool, bool, double, double, double) –> struct std::pair<bool, unsigned long>

has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, check_bonds: bool) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, check_bonds: bool, check_angles: bool) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, check_bonds: bool, check_angles: bool, max_c_n_dis: float) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, check_bonds: bool, check_angles: bool, max_c_n_dis: float, allowed_ca_c_n_deviation: float) -> Tuple[bool, int]
has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, check_bonds: bool, check_angles: bool, max_c_n_dis: float, allowed_ca_c_n_deviation: float, allowed_c_n_ca_deviation: float) -> Tuple[bool, int]

Measures C-N distance and N-Ca-C, C-N-CA bond angles to detect chainbreak/poory resolved loop residue outside cutoff.

Returns boolean and the position of found wonky peptide bond (0 if none found). Does not use AtomTree to get angles/lengths, assumes resnum is connected to resnum +1

Values are based on the CDL. No peptide bond without severe chainbreaks or missing residues should have values: out of this range. -JAB Berkholz DS, Shapovalov MV, Dunbrack RL Jr, Karplus PA (2009) Conformation dependence of backbone geometry in proteins. Structure 17: 1316-1325. deviation is +/- from the min/max values of the CDL.

cutoffs are: 1.5, 15, 15

Jared Adolf-Bryfogle (jadolfbr.com)

C++: protocols::loops::has_severe_pep_bond_geom_issues(const class core::pose::Pose &, unsigned long, bool, bool, double, double, double) –> struct std::pair<bool, unsigned long>

pyrosetta.rosetta.protocols.loops.idealize_loop(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) → None¶

set ideal BB geometry; this must occur so that loops with missing density work.

C++: protocols::loops::idealize_loop(class core::pose::Pose &, const class protocols::loops::Loop &) –> void

pyrosetta.rosetta.protocols.loops.loop_local_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) → float¶

calculate rmsd of loop residues with repect to native (loop fit)

C++: protocols::loops::loop_local_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loops::Loops &) –> double

pyrosetta.rosetta.protocols.loops.loop_rmsd(*args, **kwargs)¶

Overloaded function.

loop_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) -> float
loop_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, CA_only: bool) -> float
loop_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, CA_only: bool, bb_only: bool) -> float

calculate rmsd of loop residues with repect to native (template aligned)

C++: protocols::loops::loop_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loops::Loops &, bool, bool) –> double

pyrosetta.rosetta.protocols.loops.loop_rmsd_with_superimpose(*args, **kwargs)¶

Overloaded function.

loop_rmsd_with_superimpose(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) -> float
loop_rmsd_with_superimpose(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, CA_only: bool) -> float
loop_rmsd_with_superimpose(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, CA_only: bool, bb_only: bool) -> float

As above but actuall superimposes the non-loop part

C++: protocols::loops::loop_rmsd_with_superimpose(const class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loops::Loops &, bool, bool) –> double

pyrosetta.rosetta.protocols.loops.loop_rmsd_with_superimpose_core(*args, **kwargs)¶

Overloaded function.

loop_rmsd_with_superimpose_core(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, core: pyrosetta.rosetta.protocols.loops.Loops) -> float
loop_rmsd_with_superimpose_core(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, core: pyrosetta.rosetta.protocols.loops.Loops, CA_only: bool) -> float
loop_rmsd_with_superimpose_core(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, core: pyrosetta.rosetta.protocols.loops.Loops, CA_only: bool, bb_only: bool) -> float

As above but actually superimposes only the core part (in case there are multiple loops…)

C++: protocols::loops::loop_rmsd_with_superimpose_core(const class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loops::Loops &, const class protocols::loops::Loops &, bool, bool) –> double

pyrosetta.rosetta.protocols.loops.loopfinder(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) → None¶: C++: protocols::loops::loopfinder(class core::pose::Pose &, class protocols::loops::Loops &) –> void

pyrosetta.rosetta.protocols.loops.loops_around_residues(*args, **kwargs)¶

Overloaded function.

loops_around_residues(loops: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose, residue_indices: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None
loops_around_residues(loops: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose, residue_indices: pyrosetta.rosetta.utility.vector1_unsigned_long, gapsize: int) -> None
loops_around_residues(loops: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose, residue_indices: pyrosetta.rosetta.utility.vector1_unsigned_long, gapsize: int, extend: int) -> None

C++: protocols::loops::loops_around_residues(class protocols::loops::Loops &, const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, unsigned long, unsigned long) –> void

pyrosetta.rosetta.protocols.loops.loops_from_string(loop_str: str, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.loops.Loops¶

loop_str has the format: start:end:cut,start:end:cut and can use rosetta or pdb numbering. The return value is an owning pointer to a Loops object encoding that loop

C++: protocols::loops::loops_from_string(const std::string &, const class core::pose::Pose &) –> class std::shared_ptr<class protocols::loops::Loops>

pyrosetta.rosetta.protocols.loops.loops_set_move_map(*args, **kwargs)¶

Overloaded function.

loops_set_move_map(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, fix_template_sc: bool, mm: pyrosetta.rosetta.core.kinematics.MoveMap, neighbor_dist: float, allow_omega_move: bool, allow_takeoff_torsion_move: bool) -> None

create a MoveMap for use of minimization based on loop definition (wrapper)

C++: protocols::loops::loops_set_move_map(class core::pose::Pose &, const class protocols::loops::Loops &, const bool, class core::kinematics::MoveMap &, double, const bool, const bool) –> void

loops_set_move_map(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, fix_template_sc: bool, mm: pyrosetta.rosetta.core.kinematics.MoveMap) -> None
loops_set_move_map(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, fix_template_sc: bool, mm: pyrosetta.rosetta.core.kinematics.MoveMap, neighbor_dist: float) -> None

C++: protocols::loops::loops_set_move_map(class core::pose::Pose &, const class protocols::loops::Loops &, const bool, class core::kinematics::MoveMap &, double) –> void

loops_set_move_map(loops: pyrosetta.rosetta.protocols.loops.Loops, allow_sc_move: pyrosetta.rosetta.utility.vector1_bool, mm: pyrosetta.rosetta.core.kinematics.MoveMap) -> None

create a MoveMap for use of minimization based on loop definition

C++: protocols::loops::loops_set_move_map(const class protocols::loops::Loops &, const class utility::vector1<bool, class std::allocator<bool> > &, class core::kinematics::MoveMap &) –> void

loops_set_move_map(loops: pyrosetta.rosetta.protocols.loops.Loops, allow_sc_move: pyrosetta.rosetta.utility.vector1_bool, mm: pyrosetta.rosetta.core.kinematics.MoveMap, allow_omega_move: bool, allow_takeoff_torsion_move: bool) -> None

C++: protocols::loops::loops_set_move_map(const class protocols::loops::Loops &, const class utility::vector1<bool, class std::allocator<bool> > &, class core::kinematics::MoveMap &, const bool, const bool) –> void

pyrosetta.rosetta.protocols.loops.move_map_from_loop(*args, **kwargs)¶

Overloaded function.

move_map_from_loop(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, fix_template_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
move_map_from_loop(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, fix_template_sc: bool, neighbor_dist: float) -> pyrosetta.rosetta.core.kinematics.MoveMap
move_map_from_loop(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, fix_template_sc: bool, neighbor_dist: float, flanking_residues: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

Create a new MoveMapOP for use in minimizing the given loop.

C++: protocols::loops::move_map_from_loop(class core::pose::Pose &, const class protocols::loops::Loop &, const bool, double, const bool) –> class std::shared_ptr<class core::kinematics::MoveMap>

pyrosetta.rosetta.protocols.loops.move_map_from_loops(*args, **kwargs)¶

Overloaded function.

move_map_from_loops(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, fix_template_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
move_map_from_loops(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, fix_template_sc: bool, neighbor_dist: float) -> pyrosetta.rosetta.core.kinematics.MoveMap
move_map_from_loops(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, fix_template_sc: bool, neighbor_dist: float, flanking_residues: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

Create a new MoveMapOP for use in minimizing the given loop.

C++: protocols::loops::move_map_from_loops(class core::pose::Pose &, const class protocols::loops::Loops &, const bool, double, const bool) –> class std::shared_ptr<class core::kinematics::MoveMap>

pyrosetta.rosetta.protocols.loops.native_loop_core_CA_rmsd(native_pose: pyrosetta.rosetta.core.pose.Pose, pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, corelength: int) → float¶: C++: protocols::loops::native_loop_core_CA_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, class protocols::loops::Loops, int &) –> double

pyrosetta.rosetta.protocols.loops.pick_loops_chainbreak(query_pose: pyrosetta.rosetta.core.pose.Pose, min_loop_size: int) → pyrosetta.rosetta.protocols.loops.Loops¶: C++: protocols::loops::pick_loops_chainbreak(class core::pose::Pose &, unsigned long) –> class std::shared_ptr<class protocols::loops::Loops>

pyrosetta.rosetta.protocols.loops.pick_loops_unaligned(nres: int, unaligned_residues: pyrosetta.rosetta.utility.vector1_unsigned_long, min_loop_size: int) → pyrosetta.rosetta.protocols.loops.Loops¶: C++: protocols::loops::pick_loops_unaligned(unsigned long, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, unsigned long) –> class std::shared_ptr<class protocols::loops::Loops>

pyrosetta.rosetta.protocols.loops.read_loop_fragments(*args, **kwargs)¶

Overloaded function.

read_loop_fragments(frag_libs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_fragment_FragSet_t) -> None

C++: protocols::loops::read_loop_fragments(class std::vector<class std::shared_ptr<class core::fragment::FragSet>, class std::allocator<class std::shared_ptr<class core::fragment::FragSet> > > &) –> void

read_loop_fragments(frag_libs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_FragSet_t) -> None

C++: protocols::loops::read_loop_fragments(class utility::vector1<class std::shared_ptr<class core::fragment::FragSet>, class std::allocator<class std::shared_ptr<class core::fragment::FragSet> > > &) –> void

pyrosetta.rosetta.protocols.loops.remove_cutpoint_variants(*args, **kwargs)¶

Overloaded function.

remove_cutpoint_variants(pose: pyrosetta.rosetta.core.pose.Pose) -> None
remove_cutpoint_variants(pose: pyrosetta.rosetta.core.pose.Pose, force: bool) -> None

Remove cutpoint variants

C++: protocols::loops::remove_cutpoint_variants(class core::pose::Pose &, bool) –> void

pyrosetta.rosetta.protocols.loops.remove_missing_density(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) → None¶: Rebuild a loop via fragment insertion + ccd closure + minimization

C++: protocols::loops::remove_missing_density(class core::pose::Pose &, const class protocols::loops::Loop &) –> void

pyrosetta.rosetta.protocols.loops.remove_short_chunks(*args, **kwargs)¶

Overloaded function.

remove_short_chunks(input_chunks: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.protocols.loops.Loops
remove_short_chunks(input_chunks: pyrosetta.rosetta.protocols.loops.Loops, min_length: int) -> pyrosetta.rosetta.protocols.loops.Loops

Remove small chunks

C++: protocols::loops::remove_short_chunks(const class protocols::loops::Loops &, unsigned long) –> class protocols::loops::Loops

pyrosetta.rosetta.protocols.loops.remove_small_gaps(*args, **kwargs)¶

Overloaded function.

remove_small_gaps(input_chunks: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.protocols.loops.Loops
remove_small_gaps(input_chunks: pyrosetta.rosetta.protocols.loops.Loops, gap_size: int) -> pyrosetta.rosetta.protocols.loops.Loops

If two chunks are separated by a small gap of size <= <gap_size>, combine them

C++: protocols::loops::remove_small_gaps(const class protocols::loops::Loops &, unsigned long) –> class protocols::loops::Loops

pyrosetta.rosetta.protocols.loops.safe_set_extended_torsions_and_idealize_loops(loops: pyrosetta.rosetta.protocols.loops.Loops, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Identical to set_extended_torsions_and_idealize_loops() without the irrational: behavior surrounding empty loops.

C++: protocols::loops::safe_set_extended_torsions_and_idealize_loops(const class protocols::loops::Loops &, class core::pose::Pose *) –> void

pyrosetta.rosetta.protocols.loops.select_loop_frags(*args, **kwargs)¶

Overloaded function.

select_loop_frags(loops: pyrosetta.rosetta.protocols.loops.Loops, source: pyrosetta.rosetta.core.fragment.FragSet, loop_frags: pyrosetta.rosetta.core.fragment.FragSet) -> None
select_loop_frags(loops: pyrosetta.rosetta.protocols.loops.Loops, source: pyrosetta.rosetta.core.fragment.FragSet, loop_frags: pyrosetta.rosetta.core.fragment.FragSet, min_size: int) -> None

get frags that are fully within the Loop — shorten(=true/false) frags that are close to the end of loops.

C++: protocols::loops::select_loop_frags(const class protocols::loops::Loops &, class core::fragment::FragSet &, class core::fragment::FragSet &, unsigned long) –> void

pyrosetta.rosetta.protocols.loops.select_loop_residues(*args, **kwargs)¶

Overloaded function.

select_loop_residues(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, include_neighbors: bool, map: pyrosetta.rosetta.utility.vector1_bool) -> None
select_loop_residues(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, include_neighbors: bool, map: pyrosetta.rosetta.utility.vector1_bool, neighbor_dist: float) -> None

mark loop residues and its neighbors as necessary in a sequence map.

Uses 10A neighbor graph for neighbors THEN takes distance from selection to neighbors to trim neighbors. Excludes disulfide residues.

C++: protocols::loops::select_loop_residues(const class core::pose::Pose &, const class protocols::loops::Loops &, const bool, class utility::vector1<bool, class std::allocator<bool> > &, double) –> void

select_loop_residues(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, include_neighbors: bool) -> pyrosetta.rosetta.utility.vector1_bool
select_loop_residues(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, include_neighbors: bool, neighbor_dist: float) -> pyrosetta.rosetta.utility.vector1_bool

mark loop residues and its neighbors as necessary in a sequence map.

Uses 10A neighbor graph for neighbors THEN takes distance from selection to neighbors to trim neighbors. Excludes disulfide residues.

C++: protocols::loops::select_loop_residues(const class core::pose::Pose &, const class protocols::loops::Loops &, const bool, double) –> class utility::vector1<bool, class std::allocator<bool> >

select_loop_residues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, include_neighbors: bool, map: pyrosetta.rosetta.utility.vector1_bool) -> None
select_loop_residues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, include_neighbors: bool, map: pyrosetta.rosetta.utility.vector1_bool, neighbor_dist: float) -> None

mark loop residues and its neighbors as necessary for one loop.

Uses 10A neighbor graph for neighbors THEN takes distance from selection to neighbors to trim neighbors. Excludes disulfide residues.

C++: protocols::loops::select_loop_residues(const class core::pose::Pose &, const class protocols::loops::Loop &, const bool, class utility::vector1<bool, class std::allocator<bool> > &, double) –> void

select_loop_residues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, include_neighbors: bool) -> pyrosetta.rosetta.utility.vector1_bool
select_loop_residues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, include_neighbors: bool, neighbor_dist: float) -> pyrosetta.rosetta.utility.vector1_bool

mark loop residues and its neighbors as necessary for one loop.

Uses 10A neighbor graph for neighbors THEN takes distance from selection to neighbors to trim neighbors. Excludes disulfide residues.

C++: protocols::loops::select_loop_residues(const class core::pose::Pose &, const class protocols::loops::Loop &, const bool, double) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.loops.serialized_loops_from_string(loop_str: str, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_protocols_loops_SerializedLoop¶: C++: protocols::loops::serialized_loops_from_string(const std::string &, const class core::pose::Pose &) –> class utility::vector1<struct protocols::loops::SerializedLoop, class std::allocator<struct protocols::loops::SerializedLoop> >

pyrosetta.rosetta.protocols.loops.set_extended_torsions(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) → None¶

Set a loop to extended torsion angles.

C++: protocols::loops::set_extended_torsions(class core::pose::Pose &, const class protocols::loops::Loop &) –> void

pyrosetta.rosetta.protocols.loops.set_extended_torsions_and_idealize_loops(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) → None¶: C++: protocols::loops::set_extended_torsions_and_idealize_loops(class core::pose::Pose &, class protocols::loops::Loops) –> void

pyrosetta.rosetta.protocols.loops.set_loop_cutpoint_in_pose_fold_tree(new_cutpoint: int, pose: pyrosetta.rosetta.core.pose.Pose, loop_begin: int, loop_end: int) → None¶: C++: protocols::loops::set_loop_cutpoint_in_pose_fold_tree(const unsigned long, class core::pose::Pose &, const unsigned long, const unsigned long) –> void

pyrosetta.rosetta.protocols.loops.set_move_map_for_centroid_loop(loop: pyrosetta.rosetta.protocols.loops.Loop, mm: pyrosetta.rosetta.core.kinematics.MoveMap) → None¶: C++: protocols::loops::set_move_map_for_centroid_loop(const class protocols::loops::Loop &, class core::kinematics::MoveMap &) –> void

pyrosetta.rosetta.protocols.loops.set_secstruct_from_dssp(pose: pyrosetta.rosetta.core.pose.Pose, filename: str) → bool¶

another helper function to set secondary structure of a Pose from an external file.

C++: protocols::loops::set_secstruct_from_dssp(class core::pose::Pose &, const std::string &) –> bool

pyrosetta.rosetta.protocols.loops.set_secstruct_from_psipred_ss2(*args, **kwargs)¶

Overloaded function.

set_secstruct_from_psipred_ss2(pose: pyrosetta.rosetta.core.pose.Pose) -> bool
set_secstruct_from_psipred_ss2(pose: pyrosetta.rosetta.core.pose.Pose, filename: str) -> bool

helper function to set secondary structure of a Pose from an external: file.

C++: protocols::loops::set_secstruct_from_psipred_ss2(class core::pose::Pose &, const std::string &) –> bool

pyrosetta.rosetta.protocols.loops.set_single_loop_fold_tree(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) → None¶: Set the fold tree to contain a single chain break at the loops’ position

C++: protocols::loops::set_single_loop_fold_tree(class core::pose::Pose &, const class protocols::loops::Loop &) –> void

pyrosetta.rosetta.protocols.loops.split_by_ca_ca_dist(*args, **kwargs)¶

Overloaded function.

split_by_ca_ca_dist(pose: pyrosetta.rosetta.core.pose.Pose, input_chunks: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.protocols.loops.Loops
split_by_ca_ca_dist(pose: pyrosetta.rosetta.core.pose.Pose, input_chunks: pyrosetta.rosetta.protocols.loops.Loops, CA_CA_distance_cutoff: float) -> pyrosetta.rosetta.protocols.loops.Loops

Split into separate chunks if CA-CA distance is over the cutoff

C++: protocols::loops::split_by_ca_ca_dist(const class core::pose::Pose &, const class protocols::loops::Loops &, const double) –> class protocols::loops::Loops

pyrosetta.rosetta.protocols.loops.split_by_resSeq(*args, **kwargs)¶

Overloaded function.

split_by_resSeq(pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.loops.Loops

C++: protocols::loops::split_by_resSeq(const class core::pose::Pose &) –> class protocols::loops::Loops

split_by_resSeq(pose: pyrosetta.rosetta.core.pose.Pose, input_chunks: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.protocols.loops.Loops

C++: protocols::loops::split_by_resSeq(const class core::pose::Pose &, const class protocols::loops::Loops &) –> class protocols::loops::Loops

pyrosetta.rosetta.protocols.loops.trim_back_sequence_mapping(mapping: pyrosetta.rosetta.core.id.SequenceMapping, source_seq: str, target_seq: str, min_loop_size: int) → None¶

Given a sequence mapping which may have simple indels, trim back around those indels so that the loops can plausibly be closed.

C++: protocols::loops::trim_back_sequence_mapping(class core::id::SequenceMapping &, const std::string &, const std::string &, const unsigned long) –> void

pyrosetta.rosetta.protocols.loops.validate_loop_start_stop(prohibit_single_residue_loops: bool, start: int, stop: int, filename: str, linecount: int) → None¶

Checks if there is a problem with the beginning and ending residues defined: in a loops file.

C++: protocols::loops::validate_loop_start_stop(bool, unsigned long, unsigned long, const std::string &, unsigned long) –> void