loops

Bindings for protocols::loops namespace

class pyrosetta.rosetta.protocols.loops.EXCN_Loop_not_closed

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

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

  1. 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: pyrosetta.rosetta.protocols.moves.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_std_allocator_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.

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

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

  1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None

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

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

Set the ‘type’ string

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

  1. 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: pyrosetta.rosetta.protocols.moves.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_builtins.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.

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

set to “in charge” state.

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

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

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

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

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

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

  1. show(self: pyrosetta.rosetta.protocols.loops.Loop) -> None

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

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

  2. 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_builtins.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>
class pyrosetta.rosetta.protocols.loops.LoopFromFileData

Bases: pybind11_builtins.pybind11_object

cutpoint_res(*args, **kwargs)

Overloaded function.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Create LoopMover Reporters

create_loop_mover(*args, **kwargs)

Overloaded function.

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

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

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

used to sort Loops by start-res

assign(self: pyrosetta.rosetta.std.binary_function_double_double_bool_t, : pyrosetta.rosetta.std.binary_function_double_double_bool_t) pyrosetta.rosetta.std.binary_function_double_double_bool_t

C++: std::binary_function<double, double, bool>::operator=(const struct std::binary_function<double, double, bool> &) –> struct std::binary_function<double, double, bool> &

class pyrosetta.rosetta.protocols.loops.Loops

Bases: pybind11_builtins.pybind11_object

add_loop(*args, **kwargs)

Overloaded function.

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

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

  1. add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int) -> None

  2. add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int, cut: int) -> None

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

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

  1. add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, it: __gnu_cxx::__normal_iterator<protocols::loops::Loop const*, std::vector<protocols::loops::Loop, std::allocator<protocols::loops::Loop> > >) -> None

C++: protocols::loops::Loops::add_loop(const class __gnu_cxx::__normal_iterator<const class protocols::loops::Loop *, class std::vector<class protocols::loops::Loop, class std::allocator<class protocols::loops::Loop> > > &) –> void

  1. add_loop(self: pyrosetta.rosetta.protocols.loops.Loops, it: __gnu_cxx::__normal_iterator<protocols::loops::Loop*, std::vector<protocols::loops::Loop, std::allocator<protocols::loops::Loop> > >) -> None

C++: protocols::loops::Loops::add_loop(const class __gnu_cxx::__normal_iterator<class protocols::loops::Loop *, class std::vector<class protocols::loops::Loop, class std::allocator<class protocols::loops::Loop> > > &) –> void

add_overlap_loop(*args, **kwargs)

Overloaded function.

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

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

begin(self: pyrosetta.rosetta.protocols.loops.Loops) __gnu_cxx::__normal_iterator<protocols::loops::Loop const*, std::vector<protocols::loops::Loop, std::allocator<protocols::loops::Loop> > >

C++: protocols::loops::Loops::begin() const –> class __gnu_cxx::__normal_iterator<const class protocols::loops::Loop *, class std::vector<class protocols::loops::Loop, class std::allocator<class protocols::loops::Loop> > >

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

end(self: pyrosetta.rosetta.protocols.loops.Loops) __gnu_cxx::__normal_iterator<protocols::loops::Loop const*, std::vector<protocols::loops::Loop, std::allocator<protocols::loops::Loop> > >

C++: protocols::loops::Loops::end() const –> class __gnu_cxx::__normal_iterator<const class protocols::loops::Loop *, class std::vector<class protocols::loops::Loop, class std::allocator<class protocols::loops::Loop> > >

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.

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

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

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

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

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

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

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

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

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

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

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

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

one_random_loop(self: pyrosetta.rosetta.protocols.loops.Loops) __gnu_cxx::__normal_iterator<protocols::loops::Loop const*, std::vector<protocols::loops::Loop, std::allocator<protocols::loops::Loop> > >

C++: protocols::loops::Loops::one_random_loop() const –> class __gnu_cxx::__normal_iterator<const class protocols::loops::Loop *, class std::vector<class protocols::loops::Loop, class std::allocator<class protocols::loops::Loop> > >

push_back(*args, **kwargs)

Overloaded function.

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

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

  1. push_back(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int) -> None

  2. push_back(self: pyrosetta.rosetta.protocols.loops.Loops, start: int, stop: int, cut: int) -> None

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

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

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

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

v_begin(self: pyrosetta.rosetta.protocols.loops.Loops) __gnu_cxx::__normal_iterator<protocols::loops::Loop*, std::vector<protocols::loops::Loop, std::allocator<protocols::loops::Loop> > >

C++: protocols::loops::Loops::v_begin() –> class __gnu_cxx::__normal_iterator<class protocols::loops::Loop *, class std::vector<class protocols::loops::Loop, class std::allocator<class protocols::loops::Loop> > >

v_end(self: pyrosetta.rosetta.protocols.loops.Loops) __gnu_cxx::__normal_iterator<protocols::loops::Loop*, std::vector<protocols::loops::Loop, std::allocator<protocols::loops::Loop> > >

C++: protocols::loops::Loops::v_end() –> class __gnu_cxx::__normal_iterator<class protocols::loops::Loop *, class std::vector<class protocols::loops::Loop, class std::allocator<class protocols::loops::Loop> > >

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.

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

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

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

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

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

  2. 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: pyrosetta.rosetta.basic.resource_manager.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: pyrosetta.rosetta.basic.resource_manager.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_builtins.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.

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

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

Orders loops by start position

assign(self: pyrosetta.rosetta.std.binary_function_double_double_bool_t, : pyrosetta.rosetta.std.binary_function_double_double_bool_t) pyrosetta.rosetta.std.binary_function_double_double_bool_t

C++: std::binary_function<double, double, bool>::operator=(const struct std::binary_function<double, double, bool> &) –> struct std::binary_function<double, double, bool> &

class pyrosetta.rosetta.protocols.loops.ResidueIdentifier

Bases: pybind11_builtins.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>
class pyrosetta.rosetta.protocols.loops.SerializedLoop

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

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

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

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

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

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

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

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

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

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

  3. extract_secondary_structure_chunks(pose: pyrosetta.rosetta.core.pose.Pose, extracted_ss_types: str, gap_size: int) -> pyrosetta.rosetta.protocols.loops.Loops

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

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

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

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

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

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

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

  1. has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) -> Tuple[bool, int]

  2. has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, check_bonds: bool) -> Tuple[bool, int]

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

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

  5. 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]

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

  1. has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int) -> Tuple[bool, int]

  2. has_severe_pep_bond_geom_issues(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, check_bonds: bool) -> Tuple[bool, int]

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

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

  5. 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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1. remove_cutpoint_variants(pose: pyrosetta.rosetta.core.pose.Pose) -> None

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

  1. remove_short_chunks(input_chunks: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.protocols.loops.Loops

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

  1. remove_small_gaps(input_chunks: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.protocols.loops.Loops

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

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

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

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

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

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

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

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

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

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

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

  1. set_secstruct_from_psipred_ss2(pose: pyrosetta.rosetta.core.pose.Pose) -> bool

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

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

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

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

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