loophash

Bindings for protocols::loophash namespace

class pyrosetta.rosetta.protocols.loophash.FastGapMover

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

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_std_allocator_std_string_t

non-const accessor

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

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

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 &

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, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → 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 &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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 class std::basic_string<char> &) –> 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

C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> 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(class std::basic_ostream<char> &) 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) -> str

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

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

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.loophash.LeapIndex

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

class pyrosetta.rosetta.protocols.loophash.LocalInserter

Bases: pybind11_builtins.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: pyrosetta.rosetta.protocols.loophash.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: pyrosetta.rosetta.protocols.moves.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.

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_std_allocator_std_string_t

non-const accessor

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

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

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

mover_name() → str

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

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, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loophash::LoopHashDiversifier::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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 class std::basic_string<char> &) –> 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

C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> 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(class std::basic_ostream<char> &) 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) -> str

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

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

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoader

Bases: pyrosetta.rosetta.basic.resource_manager.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 &

classname() → str

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

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

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

class pyrosetta.rosetta.protocols.loophash.LoopHashLibraryLoaderCreator

Bases: pyrosetta.rosetta.basic.resource_manager.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: pyrosetta.rosetta.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_builtins.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(class std::basic_string<char>, 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(class std::basic_string<char>) –> void

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

Reads legacy binary dbs

C++: protocols::loophash::LoopHashMap::read_legacydb(class std::basic_string<char>) –> 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(class std::basic_string<char>) const –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashMoverWrapper

Bases: pyrosetta.rosetta.protocols.moves.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_std_allocator_std_string_t

non-const accessor

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

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

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

mover_name() → str

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

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, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::loophash::LoopHashMoverWrapper::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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 class std::basic_string<char> &) –> 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

C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> 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(class std::basic_ostream<char> &) 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) -> str

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

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

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashRelaxProtocol

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

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_std_allocator_std_string_t

non-const accessor

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

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

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

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, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → 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 &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

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

////////////////////////////end Job Distributor interface////////////////////////////////////////

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 class std::basic_string<char> &) –> 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

C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> 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(class std::basic_ostream<char> &) 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) -> str

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

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

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.loophash.LoopHashSampler

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

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

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