loophash

Bindings for protocols::loophash namespace

class pyrosetta.rosetta.protocols.loophash.BBData

Bases: pybind11_object

property angles

property extra_key

class pyrosetta.rosetta.protocols.loophash.BBExtraData

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.loophash.BBExtraData, : pyrosetta.rosetta.protocols.loophash.BBExtraData) → pyrosetta.rosetta.protocols.loophash.BBExtraData

C++: protocols::loophash::BBExtraData::operator=(const struct protocols::loophash::BBExtraData &) –> struct protocols::loophash::BBExtraData &

property pdb_id

property rotamer_id

property sequence

class pyrosetta.rosetta.protocols.loophash.BackboneDB

Bases: pybind11_object

add_extra_data(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, extra: pyrosetta.rosetta.protocols.loophash.BBExtraData) → None

C++: protocols::loophash::BackboneDB::add_extra_data(struct protocols::loophash::BBExtraData) –> void

add_pose(*args, **kwargs)

Overloaded function.

1. add_pose(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, pose: pyrosetta.rosetta.core.pose.Pose, nres: int, offset: int) -> None

2. add_pose(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, pose: pyrosetta.rosetta.core.pose.Pose, nres: int, offset: int, chunk: pyrosetta.rosetta.protocols.frag_picker.VallChunk) -> None

C++: protocols::loophash::BackboneDB::add_pose(const class core::pose::Pose &, unsigned long, unsigned long &, class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> void

add_protein(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, new_protein: pyrosetta.rosetta.protocols.loophash.BBData) → None

C++: protocols::loophash::BackboneDB::add_protein(struct protocols::loophash::BBData) –> void

angle(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, index: int, offset: int) → float

C++: protocols::loophash::BackboneDB::angle(unsigned long, unsigned long) const –> double

assign(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, : pyrosetta.rosetta.protocols.loophash.BackboneDB) → pyrosetta.rosetta.protocols.loophash.BackboneDB

C++: protocols::loophash::BackboneDB::operator=(const class protocols::loophash::BackboneDB &) –> class protocols::loophash::BackboneDB &

extra_size(self: pyrosetta.rosetta.protocols.loophash.BackboneDB) → int

C++: protocols::loophash::BackboneDB::extra_size() const –> unsigned long

get_backbone_segment(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, index: int, offset: int, len: int, bs: pyrosetta.rosetta.protocols.loophash.BackboneSegment) → None

C++: protocols::loophash::BackboneDB::get_backbone_segment(const unsigned long, const unsigned long, const unsigned long, class protocols::loophash::BackboneSegment &) const –> void

get_extra_data(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, index: int, extra: pyrosetta.rosetta.protocols.loophash.BBExtraData) → None

C++: protocols::loophash::BackboneDB::get_extra_data(unsigned long, struct protocols::loophash::BBExtraData &) const –> void

get_mem_foot_print(self: pyrosetta.rosetta.protocols.loophash.BackboneDB) → int

C++: protocols::loophash::BackboneDB::get_mem_foot_print() const –> unsigned long

get_protein(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, index: int, protein: pyrosetta.rosetta.protocols.loophash.BBData) → None

C++: protocols::loophash::BackboneDB::get_protein(unsigned long, struct protocols::loophash::BBData &) const –> void

read_db(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, filename: str, load_extra: bool) → None

C++: protocols::loophash::BackboneDB::read_db(std::string, bool) –> void

read_homologs(self: pyrosetta.rosetta.protocols.loophash.BackboneDB) → None

C++: protocols::loophash::BackboneDB::read_homologs() –> void

read_legacydb(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, filename: str) → None

C++: protocols::loophash::BackboneDB::read_legacydb(std::string) –> void

size(self: pyrosetta.rosetta.protocols.loophash.BackboneDB) → int

C++: protocols::loophash::BackboneDB::size() const –> unsigned long

write_db(self: pyrosetta.rosetta.protocols.loophash.BackboneDB, filename: str) → None

C++: protocols::loophash::BackboneDB::write_db(std::string) const –> void

class pyrosetta.rosetta.protocols.loophash.BackboneSegment

Bases: pybind11_object

apply_to_pose(*args, **kwargs)

Overloaded function.

1. apply_to_pose(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment, pose: pyrosetta.rosetta.core.pose.Pose, ir: int) -> None

2. apply_to_pose(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment, pose: pyrosetta.rosetta.core.pose.Pose, ir: int, cut: bool) -> None

C++: protocols::loophash::BackboneSegment::apply_to_pose(class core::pose::Pose &, unsigned long, bool) const –> void

compare(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment, bs1: pyrosetta.rosetta.protocols.loophash.BackboneSegment, tolerance: float) → bool

C++: protocols::loophash::BackboneSegment::compare(const class protocols::loophash::BackboneSegment &, double) const –> bool

get_mem_foot_print(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment) → int

C++: protocols::loophash::BackboneSegment::get_mem_foot_print() –> unsigned long

length(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment) → int

C++: protocols::loophash::BackboneSegment::length() const –> unsigned long

omega(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment) → pyrosetta.rosetta.std.vector_double

C++: protocols::loophash::BackboneSegment::omega() const –> const class std::vector<double, class std::allocator<double> > &

phi(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment) → pyrosetta.rosetta.std.vector_double

C++: protocols::loophash::BackboneSegment::phi() const –> const class std::vector<double, class std::allocator<double> > &

print(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment) → None

C++: protocols::loophash::BackboneSegment::print() const –> void

psi(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment) → pyrosetta.rosetta.std.vector_double

C++: protocols::loophash::BackboneSegment::psi() const –> const class std::vector<double, class std::allocator<double> > &

read_from_pose(self: pyrosetta.rosetta.protocols.loophash.BackboneSegment, pose: pyrosetta.rosetta.core.pose.Pose, ir: int, length: int) → None

C++: protocols::loophash::BackboneSegment::read_from_pose(const class core::pose::Pose &, unsigned long, unsigned long) –> void

class pyrosetta.rosetta.protocols.loophash.EXCN_DB_IO_Failed

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.loophash.EXCN_DB_IO_Failed, : pyrosetta.rosetta.protocols.loophash.EXCN_DB_IO_Failed) → pyrosetta.rosetta.protocols.loophash.EXCN_DB_IO_Failed

C++: protocols::loophash::EXCN_DB_IO_Failed::operator=(const class protocols::loophash::EXCN_DB_IO_Failed &) –> class protocols::loophash::EXCN_DB_IO_Failed &

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

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

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.loophash.EXCN_Invalid_Hashmap, : pyrosetta.rosetta.protocols.loophash.EXCN_Invalid_Hashmap) → pyrosetta.rosetta.protocols.loophash.EXCN_Invalid_Hashmap

C++: protocols::loophash::EXCN_Invalid_Hashmap::operator=(const class protocols::loophash::EXCN_Invalid_Hashmap &) –> class protocols::loophash::EXCN_Invalid_Hashmap &

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

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

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.loophash.EXCN_No_Extra_Data_To_Write, : pyrosetta.rosetta.protocols.loophash.EXCN_No_Extra_Data_To_Write) → pyrosetta.rosetta.protocols.loophash.EXCN_No_Extra_Data_To_Write

C++: protocols::loophash::EXCN_No_Extra_Data_To_Write::operator=(const class protocols::loophash::EXCN_No_Extra_Data_To_Write &) –> class protocols::loophash::EXCN_No_Extra_Data_To_Write &

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

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

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.loophash.EXCN_Wrong_DB_Format, : pyrosetta.rosetta.protocols.loophash.EXCN_Wrong_DB_Format) → pyrosetta.rosetta.protocols.loophash.EXCN_Wrong_DB_Format

C++: protocols::loophash::EXCN_Wrong_DB_Format::operator=(const class protocols::loophash::EXCN_Wrong_DB_Format &) –> class protocols::loophash::EXCN_Wrong_DB_Format &

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

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

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.loophash.EXCN_bbdb_Merge_Failed, : pyrosetta.rosetta.protocols.loophash.EXCN_bbdb_Merge_Failed) → pyrosetta.rosetta.protocols.loophash.EXCN_bbdb_Merge_Failed

C++: protocols::loophash::EXCN_bbdb_Merge_Failed::operator=(const class protocols::loophash::EXCN_bbdb_Merge_Failed &) –> class protocols::loophash::EXCN_bbdb_Merge_Failed &

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

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

Bases: Mover

Not implemented! Mover class for closing gaps.

This Mover checks for any gaps using residue residue distances, then eats back at the chain surrounding it until LoopHash finds a fragment that fits in the space without changing the rest of pose too much. This mover depends on LoopHashSampler::close_gaps(), which is currently not implemented.

apply(self: pyrosetta.rosetta.protocols.loophash.FastGapMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loophash::FastGapMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.loophash.FastGapMover, : pyrosetta.rosetta.protocols.loophash.FastGapMover) → pyrosetta.rosetta.protocols.loophash.FastGapMover

C++: protocols::loophash::FastGapMover::operator=(const class protocols::loophash::FastGapMover &) –> class protocols::loophash::FastGapMover &

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.loophash.FastGapMover) → pyrosetta.rosetta.protocols.moves.Mover

clone has to be overridden only if clone invocation is expected.

C++: protocols::loophash::FastGapMover::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.loophash.FastGapMover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::FastGapMover::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.loophash.FastGapMover) → str

C++: protocols::loophash::FastGapMover::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

max_rms(self: pyrosetta.rosetta.protocols.loophash.FastGapMover, setting: float) → pyrosetta.rosetta.protocols.loophash.FastGapMover

C++: protocols::loophash::FastGapMover::max_rms(const double) –> class protocols::loophash::FastGapMover &

min_rms(self: pyrosetta.rosetta.protocols.loophash.FastGapMover, setting: float) → pyrosetta.rosetta.protocols.loophash.FastGapMover

C++: protocols::loophash::FastGapMover::min_rms(const double) –> class protocols::loophash::FastGapMover &

static name() → str

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

non_ideal(self: pyrosetta.rosetta.protocols.loophash.FastGapMover, setting: bool) → pyrosetta.rosetta.protocols.loophash.FastGapMover

C++: protocols::loophash::FastGapMover::non_ideal(const bool) –> class protocols::loophash::FastGapMover &

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::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 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

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

Bases: pybind11_object

Store information about a particular Leap.

A LeapIndex holds the original high precision rigid body transform and an Index to a Backbone Database (BackboneDB) that has the actual phi psi angles. The storage of the precise RT takes a lot of space and may be deprecated at some point, since once it is hashed, it is rarely needed and can be recomputed if it is. Note that the length of the loop is not stored either, this is again done for saving memory, as huge lists of Leaps are typically created all with the same length. The length is stored and handled by the owner of LeapIndex list. The LeapIndex does not store the actual backbone coordinates of the Leap. It merely contains an index (the BackboneIndex) which refers to a serial store of backbone triples (phi,psi, omega) which are stored somewhere else in a BackboneDB. This is important to save memory storage since multiple Leaps can share the same backbone triple and redundant storage would be hugely wasteful.

property index

property key

property offset

class pyrosetta.rosetta.protocols.loophash.LegacyLeapIndex

Bases: pybind11_object

property ba

property rotx

property roty

property rotz

property vecx

property vecy

property vecz

class pyrosetta.rosetta.protocols.loophash.LocalInserter

Bases: pybind11_object

Manages the insertion of an arbitrary length of backbone in a local manner.

This is a pure virtual superclass, and the intention is that different subclasses can use different methods to keep the insertion local.

assign(self: pyrosetta.rosetta.protocols.loophash.LocalInserter, : pyrosetta.rosetta.protocols.loophash.LocalInserter) → pyrosetta.rosetta.protocols.loophash.LocalInserter

C++: protocols::loophash::LocalInserter::operator=(const class protocols::loophash::LocalInserter &) –> class protocols::loophash::LocalInserter &

make_local_bb_change(self: pyrosetta.rosetta.protocols.loophash.LocalInserter, start_pose: pyrosetta.rosetta.core.pose.Pose, original_pose: pyrosetta.rosetta.core.pose.Pose, new_bs: pyrosetta.rosetta.protocols.loophash.BackboneSegment, res_pos: int) → float

Insert a backbone segment.

The backbone segment to insert

The residue where the start of the given backbone segment should be inserted.

C++: protocols::loophash::LocalInserter::make_local_bb_change(class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loophash::BackboneSegment &, unsigned long) –> double

make_local_bb_change_close_gaps(self: pyrosetta.rosetta.protocols.loophash.LocalInserter, start_pose: pyrosetta.rosetta.core.pose.Pose, original_pose: pyrosetta.rosetta.core.pose.Pose, new_bs: pyrosetta.rosetta.protocols.loophash.BackboneSegment, res_pos: int) → float

Insert a backbone segment, and close any chainbreaks in the region

where the segment is being inserted.

The backbone segment to insert

The residue where the start of the given backbone segment should be inserted.

C++: protocols::loophash::LocalInserter::make_local_bb_change_close_gaps(class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loophash::BackboneSegment &, unsigned long) –> double

make_local_bb_change_include_cut(self: pyrosetta.rosetta.protocols.loophash.LocalInserter, start_pose: pyrosetta.rosetta.core.pose.Pose, original_pose: pyrosetta.rosetta.core.pose.Pose, new_bs: pyrosetta.rosetta.protocols.loophash.BackboneSegment, res_pos: int) → float

Closes many gaps outside of ir and jr.

Will die if gap exists between ir and jr.

The backbone segment to insert

The residue where the start of the given backbone segment should be inserted.

C++: protocols::loophash::LocalInserter::make_local_bb_change_include_cut(class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loophash::BackboneSegment &, unsigned long) –> double

class pyrosetta.rosetta.protocols.loophash.LocalInserter_SimpleMin

Bases: LocalInserter

Insert a backbone segment and use minimization with coordinate constraints to keep the insertion local.

assign(self: pyrosetta.rosetta.protocols.loophash.LocalInserter_SimpleMin, : pyrosetta.rosetta.protocols.loophash.LocalInserter_SimpleMin) → pyrosetta.rosetta.protocols.loophash.LocalInserter_SimpleMin

C++: protocols::loophash::LocalInserter_SimpleMin::operator=(const class protocols::loophash::LocalInserter_SimpleMin &) –> class protocols::loophash::LocalInserter_SimpleMin &

make_local_bb_change(self: pyrosetta.rosetta.protocols.loophash.LocalInserter_SimpleMin, start_pose: pyrosetta.rosetta.core.pose.Pose, original_pose: pyrosetta.rosetta.core.pose.Pose, new_bs: pyrosetta.rosetta.protocols.loophash.BackboneSegment, res_pos: int) → float

This method uses the following algorithm:

• Constrain atoms outside the region where the insertion will occur to their initial coordinates.

• Apply the torsions from the given backbone segment.

• Minimize first with only the rama term

• Minimize again with a hard-coded centroid-like score function (see LocalInserter_SimpleMin::set_default_score_functions() for details) and a stricter convergence tolerance.

C++: protocols::loophash::LocalInserter_SimpleMin::make_local_bb_change(class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loophash::BackboneSegment &, unsigned long) –> double

make_local_bb_change_close_gaps(self: pyrosetta.rosetta.protocols.loophash.LocalInserter_SimpleMin, start_pose: pyrosetta.rosetta.core.pose.Pose, original_pose: pyrosetta.rosetta.core.pose.Pose, new_bs: pyrosetta.rosetta.protocols.loophash.BackboneSegment, res_pos: int) → float

Similar to make_local_bb_change(), but before the torsions from

the given backbone segment are inserted, the bond lengths and angles for those residues are idealized, so that if there was a chainbreak, it would be fixed.

This whole function, with the exception of the “idx” for-loop, is duplicated from make_local_bb_change(). This could be easily refactored.

C++: protocols::loophash::LocalInserter_SimpleMin::make_local_bb_change_close_gaps(class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loophash::BackboneSegment &, unsigned long) –> double

make_local_bb_change_include_cut(self: pyrosetta.rosetta.protocols.loophash.LocalInserter_SimpleMin, start_pose: pyrosetta.rosetta.core.pose.Pose, original_pose: pyrosetta.rosetta.core.pose.Pose, new_bs: pyrosetta.rosetta.protocols.loophash.BackboneSegment, res_pos: int) → float

It looks to me like this method applies coordinate constraints

and inserts the given backbone segment, but never does any minimization.

C++: protocols::loophash::LocalInserter_SimpleMin::make_local_bb_change_include_cut(class core::pose::Pose &, const class core::pose::Pose &, const class protocols::loophash::BackboneSegment &, unsigned long) –> double

scorefxn_cen_cst(self: pyrosetta.rosetta.protocols.loophash.LocalInserter_SimpleMin, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Set the score function for the second round of minimization

during a loophash insert.

C++: protocols::loophash::LocalInserter_SimpleMin::scorefxn_cen_cst(const class core::scoring::ScoreFunction &) –> void

scorefxn_rama_cst(self: pyrosetta.rosetta.protocols.loophash.LocalInserter_SimpleMin, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Set the score function for the first round of minimization

during a loophash insert.

C++: protocols::loophash::LocalInserter_SimpleMin::scorefxn_rama_cst(const class core::scoring::ScoreFunction &) –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier

Bases: Mover

Use LoopHash to generate low-resolution alternate conformations for the given pose.

It’s possible to limit the amount of movement based on the secondary structure, such that secondary structure elements either move less than loops or don’t move at all. The algorithm in pseudo-code:

• Convert the pose to centroid mode.

• For num_iterations():

• Randomly pick a window to diversify with LoopHash.

• If is true and there are no loops in the

  window, skip the rest of the iteration.

• Set the amount of backbone movement to allow (i.e. minimum and maximum

  allowed RMSD of backbone segments) based on whether or not the secondary structure changes within the window.

• Keep all the insertions that pass a filter.

• Convert the best-scoring diversified pose to full-atom mode and apply it.

add_loop_size(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, loop_size: int) → None

C++: protocols::loophash::LoopHashDiversifier::add_loop_size(const unsigned long) –> void

apply(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loophash::LoopHashDiversifier::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, : pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) → pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier

C++: protocols::loophash::LoopHashDiversifier::operator=(const class protocols::loophash::LoopHashDiversifier &) –> class protocols::loophash::LoopHashDiversifier &

cenfilter(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, cenfilter: pyrosetta.rosetta.protocols.filters.Filter) → None

C++: protocols::loophash::LoopHashDiversifier::cenfilter(class std::shared_ptr<class protocols::filters::Filter>) –> void

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.loophash.LoopHashDiversifier) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashDiversifier::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.loophash.LoopHashDiversifier) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashDiversifier::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.loophash.LoopHashDiversifier) → str

C++: protocols::loophash::LoopHashDiversifier::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

loop_sizes(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::loophash::LoopHashDiversifier::loop_sizes() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

max_inter_ss_bbrms(*args, **kwargs)

Overloaded function.

1. max_inter_ss_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) -> float

C++: protocols::loophash::LoopHashDiversifier::max_inter_ss_bbrms() const –> double

2. max_inter_ss_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, max_inter_ss_bbrms: float) -> None

C++: protocols::loophash::LoopHashDiversifier::max_inter_ss_bbrms(const double) –> void

max_intra_ss_bbrms(*args, **kwargs)

Overloaded function.

1. max_intra_ss_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) -> float

C++: protocols::loophash::LoopHashDiversifier::max_intra_ss_bbrms() const –> double

2. max_intra_ss_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, max_intra_ss_bbrms: float) -> None

C++: protocols::loophash::LoopHashDiversifier::max_intra_ss_bbrms(const double) –> void

max_rms(*args, **kwargs)

Overloaded function.

1. max_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) -> float

C++: protocols::loophash::LoopHashDiversifier::max_rms() const –> double

2. max_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, max_rms: float) -> None

C++: protocols::loophash::LoopHashDiversifier::max_rms(const double) –> void

min_inter_ss_bbrms(*args, **kwargs)

Overloaded function.

1. min_inter_ss_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) -> float

C++: protocols::loophash::LoopHashDiversifier::min_inter_ss_bbrms() const –> double

2. min_inter_ss_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, min_inter_ss_bbrms: float) -> None

C++: protocols::loophash::LoopHashDiversifier::min_inter_ss_bbrms(const double) –> void

min_intra_ss_bbrms(*args, **kwargs)

Overloaded function.

1. min_intra_ss_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) -> float

C++: protocols::loophash::LoopHashDiversifier::min_intra_ss_bbrms() const –> double

2. min_intra_ss_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, min_intra_ss_bbrms: float) -> None

C++: protocols::loophash::LoopHashDiversifier::min_intra_ss_bbrms(const double) –> void

min_rms(*args, **kwargs)

Overloaded function.

1. min_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) -> float

C++: protocols::loophash::LoopHashDiversifier::min_rms() const –> double

2. min_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, min_rms: float) -> None

C++: protocols::loophash::LoopHashDiversifier::min_rms(const double) –> void

static mover_name() → str

C++: protocols::loophash::LoopHashDiversifier::mover_name() –> std::string

static name() → str

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

num_iterations(*args, **kwargs)

Overloaded function.

1. num_iterations(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) -> int

C++: protocols::loophash::LoopHashDiversifier::num_iterations() const –> unsigned long

2. num_iterations(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, num_iterations: int) -> None

C++: protocols::loophash::LoopHashDiversifier::num_iterations(const unsigned long) –> void

num_try_div(*args, **kwargs)

Overloaded function.

1. num_try_div(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) -> int

C++: protocols::loophash::LoopHashDiversifier::num_try_div() const –> unsigned long

2. num_try_div(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, num_try_div: int) -> None

C++: protocols::loophash::LoopHashDiversifier::num_try_div(const unsigned long) –> void

parse_my_tag(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None

C++: protocols::loophash::LoopHashDiversifier::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::loophash::LoopHashDiversifier::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

ranking_cenfilter(*args, **kwargs)

Overloaded function.

1. ranking_cenfilter(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier, filter: pyrosetta.rosetta.protocols.filters.Filter) -> None

C++: protocols::loophash::LoopHashDiversifier::ranking_cenfilter(class std::shared_ptr<class protocols::filters::Filter>) –> void

2. ranking_cenfilter(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifier) -> pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::loophash::LoopHashDiversifier::ranking_cenfilter() const –> class std::shared_ptr<class protocols::filters::Filter>

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

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

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifierCreator, : pyrosetta.rosetta.protocols.loophash.LoopHashDiversifierCreator) → pyrosetta.rosetta.protocols.loophash.LoopHashDiversifierCreator

C++: protocols::loophash::LoopHashDiversifierCreator::operator=(const class protocols::loophash::LoopHashDiversifierCreator &) –> class protocols::loophash::LoopHashDiversifierCreator &

create_mover(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifierCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashDiversifierCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifierCreator) → str

C++: protocols::loophash::LoopHashDiversifierCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.loophash.LoopHashDiversifierCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::loophash::LoopHashDiversifierCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashLibrary

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loophash::LoopHashLibrary::apply(class core::pose::Pose &) –> void

apply_random(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, fir: int, fjr: int, min_rms: float, max_rms: float) → None

C++: protocols::loophash::LoopHashLibrary::apply_random(class core::pose::Pose &, unsigned long &, unsigned long &, double, double) –> void

assign(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, : pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → pyrosetta.rosetta.protocols.loophash.LoopHashLibrary

C++: protocols::loophash::LoopHashLibrary::operator=(const class protocols::loophash::LoopHashLibrary &) –> class protocols::loophash::LoopHashLibrary &

backbone_database(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → pyrosetta.rosetta.protocols.loophash.BackboneDB

C++: protocols::loophash::LoopHashLibrary::backbone_database() const –> const class protocols::loophash::BackboneDB &

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.loophash.LoopHashLibrary) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashLibrary::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>

create_db(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → None

C++: protocols::loophash::LoopHashLibrary::create_db() –> void

delete_db(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → None

C++: protocols::loophash::LoopHashLibrary::delete_db() –> void

extract_data_from_pose(*args, **kwargs)

Overloaded function.

1. extract_data_from_pose(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, nres: int) -> None

2. extract_data_from_pose(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, nres: int, chunk: pyrosetta.rosetta.protocols.frag_picker.VallChunk) -> None

C++: protocols::loophash::LoopHashLibrary::extract_data_from_pose(class core::pose::Pose &, unsigned long, class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> void

3. extract_data_from_pose(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::loophash::LoopHashLibrary::extract_data_from_pose(class core::pose::Pose &) –> void

fresh_instance(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashLibrary::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_all(*args, **kwargs)

Overloaded function.

1. get_all(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, lib_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t) -> None

2. get_all(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, lib_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t, start_res: int) -> None

3. get_all(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, lib_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t, start_res: int, stop_res: int) -> None

4. get_all(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, lib_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t, start_res: int, stop_res: int, min_bbrms: float) -> None

5. get_all(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, lib_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t, start_res: int, stop_res: int, min_bbrms: float, max_bbrms: float) -> None

6. get_all(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, lib_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t, start_res: int, stop_res: int, min_bbrms: float, max_bbrms: float, min_rms: float) -> None

7. get_all(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, lib_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t, start_res: int, stop_res: int, min_bbrms: float, max_bbrms: float, min_rms: float, max_rms: float) -> None

C++: protocols::loophash::LoopHashLibrary::get_all(class core::pose::Pose &, class std::vector<class std::shared_ptr<class core::io::silent::SilentStruct>, class std::allocator<class std::shared_ptr<class core::io::silent::SilentStruct> > > &, unsigned long, unsigned long, double, double, double, double) –> void

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_extra(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → bool

C++: protocols::loophash::LoopHashLibrary::get_extra() const –> bool

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.loophash.LoopHashLibrary) → str

C++: protocols::loophash::LoopHashLibrary::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

gethash(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, size: int) → pyrosetta.rosetta.protocols.loophash.LoopHashMap

C++: protocols::loophash::LoopHashLibrary::gethash(unsigned long) –> class protocols::loophash::LoopHashMap &

graft_loop(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, src_pose: pyrosetta.rosetta.core.pose.Pose, tgt_pose: pyrosetta.rosetta.core.pose.Pose, myloop: pyrosetta.rosetta.protocols.loops.Loop) → None

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

hash_sizes(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → pyrosetta.rosetta.std.vector_unsigned_long

Return a list of the loop lengths present in the library.

C++: protocols::loophash::LoopHashLibrary::hash_sizes() const –> const class std::vector<unsigned long, class std::allocator<unsigned long> > &

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

load_db(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → None

Only support reading from text, extra data is mandatory. Used

when created merged text db.

C++: protocols::loophash::LoopHashLibrary::load_db() –> void

load_mergeddb(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → None

Only support reading from merged text. Extra data is optional

and handled by extra_.

C++: protocols::loophash::LoopHashLibrary::load_mergeddb() –> void

loopdb_range(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → Tuple[int, int]

C++: protocols::loophash::LoopHashLibrary::loopdb_range() const –> struct std::pair<unsigned long, unsigned long>

mem_foot_print(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → None

C++: protocols::loophash::LoopHashLibrary::mem_foot_print() const –> void

merge(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, second_lib: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, rms_cutoffs: pyrosetta.rosetta.utility.vector1_double) → None

Take two LoopHash libraries and merge them.

Throws out non-unique fragments defined as follows: if a new fragment is in a bucket with a key also in the master library, and if the RMS between the new fragment and the members of the master bucket is lower than the it is non-unique. Thus, an of zero will not throw away any fragments.

C++: protocols::loophash::LoopHashLibrary::merge(class std::shared_ptr<class protocols::loophash::LoopHashLibrary>, class utility::vector1<double, class std::allocator<double> >) –> void

merge_bbdb(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, second_bbdb: pyrosetta.rosetta.protocols.loophash.BackboneDB, index_offset: int) → bool

Take two backbone databases and merge them.

Just takes Data structs from one and copies to the other

C++: protocols::loophash::LoopHashLibrary::merge_bbdb(const class protocols::loophash::BackboneDB &, unsigned long &) –> bool

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::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 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

save_db(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → None

Only support writing to text, always include extra data

C++: protocols::loophash::LoopHashLibrary::save_db() const –> void

set_create_db(*args, **kwargs)

Overloaded function.

1. set_create_db(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) -> None

2. set_create_db(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, setting: bool) -> None

C++: protocols::loophash::LoopHashLibrary::set_create_db(bool) –> 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_db_path(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, setting: str) → None

C++: protocols::loophash::LoopHashLibrary::set_db_path(std::string) –> void

set_default_score_functions(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → None

C++: protocols::loophash::LoopHashLibrary::set_default_score_functions() –> 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

setup_hash_maps(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → None

C++: protocols::loophash::LoopHashLibrary::setup_hash_maps() –> 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

sort(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary) → None

This function destroys the backbone_index_map reference, so

sorting is only done when the hash will not longer be used. Required after merging, before saving so that merged db can be loaded as slices.

C++: protocols::loophash::LoopHashLibrary::sort() –> void

test_loop_sample(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, pose: pyrosetta.rosetta.core.pose.Pose, nres: int) → None

C++: protocols::loophash::LoopHashLibrary::test_loop_sample(class core::pose::Pose &, unsigned long) –> 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

test_saving_library(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibrary, : pyrosetta.rosetta.core.pose.Pose, ir: int, deposit: bool) → bool

C++: protocols::loophash::LoopHashLibrary::test_saving_library(class core::pose::Pose, unsigned long, bool) –> bool

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

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

Bases: ResourceLoader

%LoopHashLibraryLoader constructs a LoopHashLibrary instance from data provided by the %ResourceManager.

The %LoopHashLibraryLoader is given a LoopHashLibraryOptions containing a %vector of loop lengths from the ResourceManager. This information is then used to produce a LoopHashLibraryCOP to return to the protocol.

assign(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoader, : pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoader) → pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoader

C++: protocols::loophash::LoopHashLibraryLoader::operator=(const class protocols::loophash::LoopHashLibraryLoader &) –> class protocols::loophash::LoopHashLibraryLoader &

static classname() → str

C++: protocols::loophash::LoopHashLibraryLoader::classname() –> std::string

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

C++: protocols::loophash::LoopHashLibraryLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoaderCreator

Bases: ResourceLoaderCreator

%LoopHashLibraryLoaderCreator allows the ResourceLoaderFactory to create a LoopHashLibraryLoader instance.

The LoopHashLibraryLoader class can be constructed from the string “LoopHashLibrary”, 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.loophash.LoopHashLibraryLoaderCreator, : pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoaderCreator) → pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoaderCreator

C++: protocols::loophash::LoopHashLibraryLoaderCreator::operator=(const class protocols::loophash::LoopHashLibraryLoaderCreator &) –> class protocols::loophash::LoopHashLibraryLoaderCreator &

create_resource_loader(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoaderCreator) → pyrosetta.rosetta.basic.resource_manager.ResourceLoader

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

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

loader_type(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoaderCreator) → str

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

C++: protocols::loophash::LoopHashLibraryLoaderCreator::loader_type() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::loophash::LoopHashLibraryLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashMap

Bases: pybind11_object

the loop hash map stores LeapIndexes and a hashmap to access those LeapIndexes quickly by their 6D coordinates.

add_leap(*args, **kwargs)

Overloaded function.

1. add_leap(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, leap_index: pyrosetta.rosetta.protocols.loophash.LeapIndex, transform: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) -> None

Add a leap/loop to the HashMap

C++: protocols::loophash::LoopHashMap::add_leap(const struct protocols::loophash::LeapIndex &, class utility::fixedsizearray1<double, 6> &) –> void

2. add_leap(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, leap_index: pyrosetta.rosetta.protocols.loophash.LeapIndex, key: int) -> None

Add a leap/loop to the HashMap with a key, skipping hashing

C++: protocols::loophash::LoopHashMap::add_leap(const struct protocols::loophash::LeapIndex &, unsigned long) –> void

add_legacyleap(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, legacyleap_index: pyrosetta.rosetta.protocols.loophash.LegacyLeapIndex) → None

Add an legacy leap/loop to the HashMap

C++: protocols::loophash::LoopHashMap::add_legacyleap(const struct protocols::loophash::LegacyLeapIndex &) –> void

assign(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, other: pyrosetta.rosetta.protocols.loophash.LoopHashMap) → pyrosetta.rosetta.protocols.loophash.LoopHashMap

C++: protocols::loophash::LoopHashMap::operator=(const class protocols::loophash::LoopHashMap &) –> class protocols::loophash::LoopHashMap &

get_loop_size(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap) → int

Query the loopsize of this LoopHashMap

C++: protocols::loophash::LoopHashMap::get_loop_size() const –> unsigned long

get_peptide(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, index: int) → pyrosetta.rosetta.protocols.loophash.LeapIndex

Obtain an index to a given peptide saved

C++: protocols::loophash::LoopHashMap::get_peptide(unsigned long) const –> const struct protocols::loophash::LeapIndex &

lookup(*args, **kwargs)

Overloaded function.

1. lookup(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, transform: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t, result: pyrosetta.rosetta.std.vector_unsigned_long) -> None

Append to a bucket of vectors in the appropriate bin, lookup by transform

C++: protocols::loophash::LoopHashMap::lookup(class utility::fixedsizearray1<double, 6>, class std::vector<unsigned long, class std::allocator<unsigned long> > &) const –> void

2. lookup(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, index: int, result: pyrosetta.rosetta.std.vector_unsigned_long) -> None

Append to a bucket of vectors in the appropriate bin, lookup by bin index

Using core::Size instead of boost::uinst64_t

C++: protocols::loophash::LoopHashMap::lookup(unsigned long, class std::vector<unsigned long, class std::allocator<unsigned long> > &) const –> void

lookup_withkey(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, key: int, result: pyrosetta.rosetta.std.vector_unsigned_long) → None

Return a vector of loops with equal keys given a key

C++: protocols::loophash::LoopHashMap::lookup_withkey(unsigned long, class std::vector<unsigned long, class std::allocator<unsigned long> > &) const –> void

mem_foot_print(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap) → None

Return the memory usage of this class

C++: protocols::loophash::LoopHashMap::mem_foot_print() const –> void

n_loops(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap) → int

C++: protocols::loophash::LoopHashMap::n_loops() const –> unsigned long

radial_count(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, radius: int, center: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) → int

count hits in the appropriate bin, radial lookup by transform

C++: protocols::loophash::LoopHashMap::radial_count(unsigned long, class utility::fixedsizearray1<double, 6>) const –> unsigned long

radial_lookup(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, radius: int, transform: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t, result: pyrosetta.rosetta.std.vector_unsigned_long) → None

Append to a bucket of vectors in the appropriate bin, radial lookup by transform

C++: protocols::loophash::LoopHashMap::radial_lookup(unsigned long, class utility::fixedsizearray1<double, 6>, class std::vector<unsigned long, class std::allocator<unsigned long> > &) const –> void

radial_lookup_withkey(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, key: int, radius: int, result: pyrosetta.rosetta.std.vector_unsigned_long) → None

Return a vector of loops with equal keys given a key

C++: protocols::loophash::LoopHashMap::radial_lookup_withkey(unsigned long, unsigned long, class std::vector<unsigned long, class std::allocator<unsigned long> > &) const –> void

read_db(*args, **kwargs)

Overloaded function.

1. read_db(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, filename: str, loopdb_range: Tuple[int, int], homolog_index: pyrosetta.rosetta.std.map_unsigned_long_bool) -> None

Basic IO functionality - allows reading and writing text states to/from disk

C++: protocols::loophash::LoopHashMap::read_db(std::string, struct std::pair<unsigned long, unsigned long>, class std::map<unsigned long, bool, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, bool> > > &) –> void

2. read_db(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, filename: str) -> None

C++: protocols::loophash::LoopHashMap::read_db(std::string) –> void

read_legacydb(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, filename: str) → None

Reads legacy binary dbs

C++: protocols::loophash::LoopHashMap::read_legacydb(std::string) –> void

return_key(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, bb_index: int) → int

Returns a hashmap key given a member of a bucket

Don’t think boost implements this, have to manually look it up

C++: protocols::loophash::LoopHashMap::return_key(unsigned long) const –> unsigned long

sort(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap) → None

Sorts the loopdb_ by leap_index.index

C++: protocols::loophash::LoopHashMap::sort() –> void

write_db(self: pyrosetta.rosetta.protocols.loophash.LoopHashMap, filename: str) → None

Basic IO functionality - allows reading and writing text states to/from disk

C++: protocols::loophash::LoopHashMap::write_db(std::string) const –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper

Bases: Mover

Use LoopHash to sample new high-resolution conformations for the given pose.

The algorithm in pseudo-code: - Insert as many loops as you can into the regions you’re interested in. - Score each insertion using the “centroid” filter, and discard the ones

that don’t score well if you have too many.

• Use FastRelax in “batch-mode” (what’s that? KBK) to relax the remaining insertions with a full-atom score function.

• Score each relaxed structure using the “fullatom” filter.

• Apply the best-scoring one.

add_loop_size(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, loop_size: int) → None

C++: protocols::loophash::LoopHashMoverWrapper::add_loop_size(const unsigned long) –> void

apply(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loophash::LoopHashMoverWrapper::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, : pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) → pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper

C++: protocols::loophash::LoopHashMoverWrapper::operator=(const class protocols::loophash::LoopHashMoverWrapper &) –> class protocols::loophash::LoopHashMoverWrapper &

cenfilter(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, cenfilter: pyrosetta.rosetta.protocols.filters.Filter) → None

C++: protocols::loophash::LoopHashMoverWrapper::cenfilter(class std::shared_ptr<class protocols::filters::Filter>) –> void

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.loophash.LoopHashMoverWrapper) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashMoverWrapper::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>

fafilter(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, fafilter: pyrosetta.rosetta.protocols.filters.Filter) → None

C++: protocols::loophash::LoopHashMoverWrapper::fafilter(class std::shared_ptr<class protocols::filters::Filter>) –> void

fresh_instance(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashMoverWrapper::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_additional_output(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::loophash::LoopHashMoverWrapper::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.loophash.LoopHashMoverWrapper) → str

C++: protocols::loophash::LoopHashMoverWrapper::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

loop_sizes(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::loophash::LoopHashMoverWrapper::loop_sizes() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

max_bbrms(*args, **kwargs)

Overloaded function.

1. max_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) -> float

C++: protocols::loophash::LoopHashMoverWrapper::max_bbrms() const –> double

2. max_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, max_bbrms: float) -> None

C++: protocols::loophash::LoopHashMoverWrapper::max_bbrms(const double) –> void

max_nstruct(*args, **kwargs)

Overloaded function.

1. max_nstruct(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) -> int

C++: protocols::loophash::LoopHashMoverWrapper::max_nstruct() const –> unsigned long

2. max_nstruct(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, max_nstruct: int) -> None

C++: protocols::loophash::LoopHashMoverWrapper::max_nstruct(const unsigned long) –> void

max_rms(*args, **kwargs)

Overloaded function.

1. max_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) -> float

C++: protocols::loophash::LoopHashMoverWrapper::max_rms() const –> double

2. max_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, max_rms: float) -> None

C++: protocols::loophash::LoopHashMoverWrapper::max_rms(const double) –> void

min_bbrms(*args, **kwargs)

Overloaded function.

1. min_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) -> float

C++: protocols::loophash::LoopHashMoverWrapper::min_bbrms() const –> double

2. min_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, min_bbrms: float) -> None

C++: protocols::loophash::LoopHashMoverWrapper::min_bbrms(const double) –> void

min_rms(*args, **kwargs)

Overloaded function.

1. min_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) -> float

C++: protocols::loophash::LoopHashMoverWrapper::min_rms() const –> double

2. min_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, min_rms: float) -> None

C++: protocols::loophash::LoopHashMoverWrapper::min_rms(const double) –> void

static mover_name() → str

C++: protocols::loophash::LoopHashMoverWrapper::mover_name() –> std::string

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None

C++: protocols::loophash::LoopHashMoverWrapper::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::loophash::LoopHashMoverWrapper::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

ranking_cenfilter(*args, **kwargs)

Overloaded function.

1. ranking_cenfilter(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, filter: pyrosetta.rosetta.protocols.filters.Filter) -> None

C++: protocols::loophash::LoopHashMoverWrapper::ranking_cenfilter(class std::shared_ptr<class protocols::filters::Filter>) –> void

2. ranking_cenfilter(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper) -> pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::loophash::LoopHashMoverWrapper::ranking_cenfilter() const –> class std::shared_ptr<class protocols::filters::Filter>

ranking_fafilter(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, ranking_fafilter: pyrosetta.rosetta.protocols.filters.Filter) → None

C++: protocols::loophash::LoopHashMoverWrapper::ranking_fafilter(class std::shared_ptr<class protocols::filters::Filter>) –> 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

relax_mover(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper, relax_mover: pyrosetta.rosetta.protocols.relax.FastRelax) → None

C++: protocols::loophash::LoopHashMoverWrapper::relax_mover(class std::shared_ptr<class protocols::relax::FastRelax>) –> void

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

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

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapperCreator, : pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapperCreator) → pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapperCreator

C++: protocols::loophash::LoopHashMoverWrapperCreator::operator=(const class protocols::loophash::LoopHashMoverWrapperCreator &) –> class protocols::loophash::LoopHashMoverWrapperCreator &

create_mover(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapperCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashMoverWrapperCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapperCreator) → str

C++: protocols::loophash::LoopHashMoverWrapperCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapperCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::loophash::LoopHashMoverWrapperCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashRelaxProtocol

Bases: Mover

Not implemented!

apply(self: pyrosetta.rosetta.protocols.loophash.LoopHashRelaxProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loophash::LoopHashRelaxProtocol::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.loophash.LoopHashRelaxProtocol, : pyrosetta.rosetta.protocols.loophash.LoopHashRelaxProtocol) → pyrosetta.rosetta.protocols.loophash.LoopHashRelaxProtocol

C++: protocols::loophash::LoopHashRelaxProtocol::operator=(const class protocols::loophash::LoopHashRelaxProtocol &) –> class protocols::loophash::LoopHashRelaxProtocol &

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.loophash.LoopHashRelaxProtocol) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashRelaxProtocol::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.loophash.LoopHashRelaxProtocol) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::LoopHashRelaxProtocol::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.loophash.LoopHashRelaxProtocol) → str

C++: protocols::loophash::LoopHashRelaxProtocol::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

manual_call(self: pyrosetta.rosetta.protocols.loophash.LoopHashRelaxProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loophash::LoopHashRelaxProtocol::manual_call(class core::pose::Pose &) –> void

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::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 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

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

Bases: pybind11_object

Create candidate structures where some residues have been sampled by loophash.

assign(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, : pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → pyrosetta.rosetta.protocols.loophash.LoopHashSampler

C++: protocols::loophash::LoopHashSampler::operator=(const class protocols::loophash::LoopHashSampler &) –> class protocols::loophash::LoopHashSampler &

build_structures(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, start_pose: pyrosetta.rosetta.core.pose.Pose, lib_structs: pyrosetta.rosetta.std.vector_std_shared_ptr_core_io_silent_SilentStruct_t) → None

Create a set of structures for the given range of residues and

other parameters stored in this class.

The pose to sample.

The resulting structures.

The algorithm, in pseudocode: - For each residue between and

• For each loop length in the database - Calculate the rigid-body transformation between the ends of a loop

  starting at the current residue and extending the current length.

  • For each radius from 0 to - Do a radial hashmap search for that radius. - For each hit:

    • Discard if the RMSD to the starting pose is either too low or too high

    • Discard if there are Ramachandran outliers.

    • Otherwise, keep!

    • For each remaining hit: - Insert the hit into a copy of the starting pose. - Create a silent file representation of that pose and some

      information describing to how it was generated, and add it to

C++: protocols::loophash::LoopHashSampler::build_structures(const class core::pose::Pose &, class std::vector<class std::shared_ptr<class core::io::silent::SilentStruct>, class std::allocator<class std::shared_ptr<class core::io::silent::SilentStruct> > > &) –> void

close_gaps(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, start_pose: pyrosetta.rosetta.core.pose.Pose, lib_structs: pyrosetta.rosetta.std.vector_core_pose_Pose, loop_size: int) → None

Not implemented! Create a set of structures with closed gaps.

C++: protocols::loophash::LoopHashSampler::close_gaps(const class core::pose::Pose &, class std::vector<class core::pose::Pose, class std::allocator<class core::pose::Pose> > &, unsigned long) –> void

get_filter_by_phipsi(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → bool

C++: protocols::loophash::LoopHashSampler::get_filter_by_phipsi() –> bool

get_max_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → float

C++: protocols::loophash::LoopHashSampler::get_max_bbrms() –> double

get_max_nstruct(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → int

C++: protocols::loophash::LoopHashSampler::get_max_nstruct() –> unsigned long

get_max_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → float

C++: protocols::loophash::LoopHashSampler::get_max_rms() –> double

get_min_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → float

C++: protocols::loophash::LoopHashSampler::get_min_bbrms() –> double

get_min_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → float

C++: protocols::loophash::LoopHashSampler::get_min_rms() –> double

get_start_res(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → int

C++: protocols::loophash::LoopHashSampler::get_start_res() –> unsigned long

get_stop_res(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → int

C++: protocols::loophash::LoopHashSampler::get_stop_res() –> unsigned long

set_defaults(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler) → None

Load default values from the command line.

C++: protocols::loophash::LoopHashSampler::set_defaults() –> void

set_filter_by_phipsi(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: bool) → None

C++: protocols::loophash::LoopHashSampler::set_filter_by_phipsi(bool) –> void

set_max_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: float) → None

C++: protocols::loophash::LoopHashSampler::set_max_bbrms(double) –> void

set_max_nstruct(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: int) → None

C++: protocols::loophash::LoopHashSampler::set_max_nstruct(unsigned long) –> void

set_max_radius(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: int) → None

C++: protocols::loophash::LoopHashSampler::set_max_radius(unsigned long) –> void

set_max_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: float) → None

C++: protocols::loophash::LoopHashSampler::set_max_rms(double) –> void

set_max_struct(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: int) → None

C++: protocols::loophash::LoopHashSampler::set_max_struct(unsigned long) –> void

set_max_struct_per_radius(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: int) → None

C++: protocols::loophash::LoopHashSampler::set_max_struct_per_radius(unsigned long) –> void

set_min_bbrms(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: float) → None

C++: protocols::loophash::LoopHashSampler::set_min_bbrms(double) –> void

set_min_rms(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: float) → None

C++: protocols::loophash::LoopHashSampler::set_min_rms(double) –> void

set_nonideal(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: bool) → None

C++: protocols::loophash::LoopHashSampler::set_nonideal(bool) –> void

set_start_res(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: int) → None

Set the first residue to sample.

C++: protocols::loophash::LoopHashSampler::set_start_res(unsigned long) –> void

set_stop_res(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, value: int) → None

Set the last residue to sample.

C++: protocols::loophash::LoopHashSampler::set_stop_res(unsigned long) –> void

use_prefiltering(self: pyrosetta.rosetta.protocols.loophash.LoopHashSampler, score_filt: pyrosetta.rosetta.core.scoring.ScoreFunction, nstruct: int) → None

Pre-filter structures with a scorefunction.

This is done using a chainbroken pose (before constraint minimization!) and is useful for experimentally derived scorefunctions (eg density).

C++: protocols::loophash::LoopHashSampler::use_prefiltering(class std::shared_ptr<class core::scoring::ScoreFunction>, unsigned long) –> void

class pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine

Bases: MPI_WorkUnitManager

assign(self: pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine, : pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine) → pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine

C++: protocols::loophash::MPI_LoopHashRefine::operator=(const class protocols::loophash::MPI_LoopHashRefine &) –> class protocols::loophash::MPI_LoopHashRefine &

go(self: pyrosetta.rosetta.protocols.wum.MPI_WorkUnitManager) → None

C++: protocols::wum::MPI_WorkUnitManager::go() –> void

inbound(self: pyrosetta.rosetta.protocols.wum.WorkUnitManager) → pyrosetta.rosetta.protocols.wum.WorkUnitQueue

C++: protocols::wum::WorkUnitManager::inbound() –> class protocols::wum::WorkUnitQueue &

outbound(self: pyrosetta.rosetta.protocols.wum.WorkUnitManager) → pyrosetta.rosetta.protocols.wum.WorkUnitQueue

C++: protocols::wum::WorkUnitManager::outbound() –> class protocols::wum::WorkUnitQueue &

register_work_units(self: pyrosetta.rosetta.protocols.wum.WorkUnitManager, work_unit_list: pyrosetta.rosetta.protocols.wum.WorkUnitList) → None

C++: protocols::wum::WorkUnitManager::register_work_units(const class protocols::wum::WorkUnitList &) –> void

set_defaults(self: pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine) → None

C++: protocols::loophash::MPI_LoopHashRefine::set_defaults() –> void

class pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine_Emperor

Bases: MPI_LoopHashRefine

assign(self: pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine_Emperor, : pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine_Emperor) → pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine_Emperor

C++: protocols::loophash::MPI_LoopHashRefine_Emperor::operator=(const class protocols::loophash::MPI_LoopHashRefine_Emperor &) –> class protocols::loophash::MPI_LoopHashRefine_Emperor &

go(self: pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine_Emperor) → None

C++: protocols::loophash::MPI_LoopHashRefine_Emperor::go() –> void

inbound(self: pyrosetta.rosetta.protocols.wum.WorkUnitManager) → pyrosetta.rosetta.protocols.wum.WorkUnitQueue

C++: protocols::wum::WorkUnitManager::inbound() –> class protocols::wum::WorkUnitQueue &

outbound(self: pyrosetta.rosetta.protocols.wum.WorkUnitManager) → pyrosetta.rosetta.protocols.wum.WorkUnitQueue

C++: protocols::wum::WorkUnitManager::outbound() –> class protocols::wum::WorkUnitQueue &

register_work_units(self: pyrosetta.rosetta.protocols.wum.WorkUnitManager, work_unit_list: pyrosetta.rosetta.protocols.wum.WorkUnitList) → None

C++: protocols::wum::WorkUnitManager::register_work_units(const class protocols::wum::WorkUnitList &) –> void

set_defaults(self: pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine_Emperor) → None

C++: protocols::loophash::MPI_LoopHashRefine_Emperor::set_defaults() –> void

class pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine_Master

Bases: MPI_LoopHashRefine

assign(self: pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine, : pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine) → pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine

C++: protocols::loophash::MPI_LoopHashRefine::operator=(const class protocols::loophash::MPI_LoopHashRefine &) –> class protocols::loophash::MPI_LoopHashRefine &

go(self: pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine_Master) → None

C++: protocols::loophash::MPI_LoopHashRefine_Master::go() –> void

inbound(self: pyrosetta.rosetta.protocols.wum.WorkUnitManager) → pyrosetta.rosetta.protocols.wum.WorkUnitQueue

C++: protocols::wum::WorkUnitManager::inbound() –> class protocols::wum::WorkUnitQueue &

outbound(self: pyrosetta.rosetta.protocols.wum.WorkUnitManager) → pyrosetta.rosetta.protocols.wum.WorkUnitQueue

C++: protocols::wum::WorkUnitManager::outbound() –> class protocols::wum::WorkUnitQueue &

register_work_units(self: pyrosetta.rosetta.protocols.wum.WorkUnitManager, work_unit_list: pyrosetta.rosetta.protocols.wum.WorkUnitList) → None

C++: protocols::wum::WorkUnitManager::register_work_units(const class protocols::wum::WorkUnitList &) –> void

set_defaults(self: pyrosetta.rosetta.protocols.loophash.MPI_LoopHashRefine_Master) → None

C++: protocols::loophash::MPI_LoopHashRefine_Master::set_defaults() –> void

class pyrosetta.rosetta.protocols.loophash.Mover_LoopHashRefine

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.loophash.Mover_LoopHashRefine, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loophash::Mover_LoopHashRefine::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.loophash.Mover_LoopHashRefine, : pyrosetta.rosetta.protocols.loophash.Mover_LoopHashRefine) → pyrosetta.rosetta.protocols.loophash.Mover_LoopHashRefine

C++: protocols::loophash::Mover_LoopHashRefine::operator=(const class protocols::loophash::Mover_LoopHashRefine &) –> class protocols::loophash::Mover_LoopHashRefine &

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.loophash.Mover_LoopHashRefine) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::Mover_LoopHashRefine::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.loophash.Mover_LoopHashRefine) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::loophash::Mover_LoopHashRefine::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.loophash.Mover_LoopHashRefine) → str

C++: protocols::loophash::Mover_LoopHashRefine::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

static name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::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 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

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

Get the set ‘type’ string

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

pyrosetta.rosetta.protocols.loophash.RealAngleToShort(angle: float) → int

C++: protocols::loophash::RealAngleToShort(double) –> short

pyrosetta.rosetta.protocols.loophash.ShortToRealAngle(angle: int) → float

C++: protocols::loophash::ShortToRealAngle(short) –> double

class pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash

Bases: WorkUnit_SilentStructStore

class WU_Header

Bases: pybind11_object

this structure can contain any non-dynamicly allocated data. Any simple data types can be used here, ints, real, floats, char, etc..

assign(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase.WU_Header, : pyrosetta.rosetta.protocols.wum.WorkUnitBase.WU_Header) → pyrosetta.rosetta.protocols.wum.WorkUnitBase.WU_Header

C++: protocols::wum::WorkUnitBase::WU_Header::operator=(const struct protocols::wum::WorkUnitBase::WU_Header &) –> struct protocols::wum::WorkUnitBase::WU_Header &

property extra_data_1_

property extra_data_2_

property extra_data_3_

property extra_data_4_

property id_

property unixtime_creation_

property unixtime_start_

property unixtime_stop_

add_blacklist(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, mpi_rank: int) → None

Adds to the blacklist

C++: protocols::wum::WorkUnitBase::add_blacklist(int) –> void

assign(self: pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash, : pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash) → pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash

C++: protocols::loophash::WorkUnit_LoopHash::operator=(const class protocols::loophash::WorkUnit_LoopHash &) –> class protocols::loophash::WorkUnit_LoopHash &

clear_blacklist(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → None

Erases the blacklist

C++: protocols::wum::WorkUnitBase::clear_blacklist() –> void

clear_serial_data(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → None

Remove all data, make sure that the memory is also cleared, hence the cals to reserve

C++: protocols::wum::WorkUnitBase::clear_serial_data() –> void

clone(self: pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash) → pyrosetta.rosetta.protocols.wum.WorkUnitBase

C++: protocols::loophash::WorkUnit_LoopHash::clone() const –> class std::shared_ptr<class protocols::wum::WorkUnitBase>

decoys(self: pyrosetta.rosetta.protocols.wum.WorkUnit_SilentStructStore) → pyrosetta.rosetta.protocols.wum.SilentStructStore

Accessor for decoy store

C++: protocols::wum::WorkUnit_SilentStructStore::decoys() –> class protocols::wum::SilentStructStore &

deserialize(self: pyrosetta.rosetta.protocols.wum.WorkUnit_SilentStructStore) → None

Make ready for working

C++: protocols::wum::WorkUnit_SilentStructStore::deserialize() –> void

extra_data_1(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Accessor to the extra_data_1 and 3 field of the header

C++: protocols::wum::WorkUnitBase::extra_data_1() –> unsigned long

extra_data_2(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

C++: protocols::wum::WorkUnitBase::extra_data_2() –> unsigned long

extra_data_3(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

C++: protocols::wum::WorkUnitBase::extra_data_3() –> unsigned long

get_options(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → str

Optain the options string from the header

C++: protocols::wum::WorkUnitBase::get_options() const –> std::string

get_run_time(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Returns the differrence between unix start and stop times

C++: protocols::wum::WorkUnitBase::get_run_time() –> unsigned long

get_wu_type(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → str

Accessor to header structure, return the WorkUnit Type

C++: protocols::wum::WorkUnitBase::get_wu_type() const –> std::string

id(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Accessor to the ID of the WorkUnit

C++: protocols::wum::WorkUnitBase::id() –> unsigned long

in_blacklist(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, mpi_rank: int) → bool

Finds in blacklist, true if is, false if it isn’t

C++: protocols::wum::WorkUnitBase::in_blacklist(int) –> bool

init_from_cmd(self: pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash, mpi_rank: int) → None

C++: protocols::loophash::WorkUnit_LoopHash::init_from_cmd(const unsigned long) –> void

last_received_from(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

C++: protocols::wum::WorkUnitBase::last_received_from() –> unsigned long

mem_footprint(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase) → int

Return the memory usage of this WorkUnit

C++: protocols::wum::WorkUnitBase::mem_footprint() const –> unsigned long

print(*args, **kwargs)

Overloaded function.

1. print(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, out: pyrosetta.rosetta.std.ostream) -> None

2. print(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, out: pyrosetta.rosetta.std.ostream, verbose: bool) -> None

Print header information to the stream, single line by default or verbose if verbose is set to true

C++: protocols::wum::WorkUnitBase::print(std::ostream &, bool) const –> void

run(self: pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash) → None

C++: protocols::loophash::WorkUnit_LoopHash::run() –> void

serialize(self: pyrosetta.rosetta.protocols.wum.WorkUnit_SilentStructStore) → None

write decoys into serial data store overwritinge whatever was there before. It basically syncs the silent struct store with the derial data

C++: protocols::wum::WorkUnit_SilentStructStore::serialize() –> void

set_end(self: pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash, end_ir: int) → None

C++: protocols::loophash::WorkUnit_LoopHash::set_end(unsigned long) –> void

set_extra_data_1(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, value: int) → None

C++: protocols::wum::WorkUnitBase::set_extra_data_1(const unsigned long) –> void

set_extra_data_2(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, value: int) → None

C++: protocols::wum::WorkUnitBase::set_extra_data_2(const unsigned long) –> void

set_extra_data_3(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, value: int) → None

C++: protocols::wum::WorkUnitBase::set_extra_data_3(const unsigned long) –> void

set_options(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, text: str) → None

Accesor to the “options” text field

C++: protocols::wum::WorkUnitBase::set_options(const std::string &) –> void

set_ssid(self: pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash, ssid: int) → None

C++: protocols::loophash::WorkUnit_LoopHash::set_ssid(unsigned long) –> void

set_start(self: pyrosetta.rosetta.protocols.loophash.WorkUnit_LoopHash, start_ir: int) → None

C++: protocols::loophash::WorkUnit_LoopHash::set_start(unsigned long) –> void

set_wu_type(self: pyrosetta.rosetta.protocols.wum.WorkUnitBase, text: str) → None

Accessor to header structure, sets the WorkUnit Type

C++: protocols::wum::WorkUnitBase::set_wu_type(const std::string &) –> void

pyrosetta.rosetta.protocols.loophash.get_rmsd(bs1: pyrosetta.rosetta.protocols.loophash.BackboneSegment, bs2: pyrosetta.rosetta.protocols.loophash.BackboneSegment) → float

C++: protocols::loophash::get_rmsd(const class protocols::loophash::BackboneSegment &, const class protocols::loophash::BackboneSegment &) –> double

pyrosetta.rosetta.protocols.loophash.get_rt_over_leap(orig_pose: pyrosetta.rosetta.core.pose.Pose, ir: int, jr: int, rt_6: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) → bool

This takes a pose and two residue positions and determines the rigid body transform of the Leap described by those two residues.

Returns true is successful or false if something went haywire and one should just ignore this loop (this can happen at the ends)

C++: protocols::loophash::get_rt_over_leap(const class core::pose::Pose &, unsigned long, unsigned long, class utility::fixedsizearray1<double, 6> &) –> bool

pyrosetta.rosetta.protocols.loophash.get_rt_over_leap_fast(pose: pyrosetta.rosetta.core.pose.Pose, ir: int, jr: int, rt_6: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) → bool

This takes a pose and two residue positions and determines the rigid body transform of the Leap described by those two residues

Returns true is successful or false if something went haywire and one should just ignore this loop (this can happen at the ends)

THe difference between this and the get_rt_over_leap function is that this version doesnt make a copy of the pose which makes it faster.

However this means that the pose passed cannot be a const pose, even though the function restores the fold tree afterwards..

C++: protocols::loophash::get_rt_over_leap_fast(class core::pose::Pose &, unsigned long, unsigned long, class utility::fixedsizearray1<double, 6> &) –> bool

pyrosetta.rosetta.protocols.loophash.get_rt_over_leap_without_foldtree_bs(pose: pyrosetta.rosetta.core.pose.Pose, ir: int, jr: int, rt_6: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) → bool

This takes a pose and two residue positions and determines the rigid body transform of the Leap described by those two residues.

C++: protocols::loophash::get_rt_over_leap_without_foldtree_bs(const class core::pose::Pose &, unsigned long, unsigned long, class utility::fixedsizearray1<double, 6> &) –> bool

pyrosetta.rosetta.protocols.loophash.loophash_main() → int

C++: protocols::loophash::loophash_main() –> int