backrub

Bindings for protocols::backrub namespace

class pyrosetta.rosetta.protocols.backrub.BackrubMover

Bases: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover

class for applying backrub moves to arbitrary protein segments

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, arg0: pyrosetta.rosetta.protocols.backrub.BackrubMover) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_mainchain_segments(*args, **kwargs)

Overloaded function.

1. add_mainchain_segments(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, atomids: pyrosetta.rosetta.utility.vector1_core_id_AtomID, min_atoms: int, max_atoms: int) -> int

add segments between a list of mainchain atomids

C++: protocols::backrub::BackrubMover::add_mainchain_segments(class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> >, unsigned long, unsigned long) –> unsigned long

2. add_mainchain_segments(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, resnums: pyrosetta.rosetta.utility.vector1_unsigned_long, atomnames: pyrosetta.rosetta.utility.vector1_std_string, min_atoms: int, max_atoms: int) -> int

add segments between mainchain atoms in contiguous stretches of residues

C++: protocols::backrub::BackrubMover::add_mainchain_segments(class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >, unsigned long, unsigned long) –> unsigned long

3. add_mainchain_segments(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) -> int

add segments between mainchain atoms using stored parameters

C++: protocols::backrub::BackrubMover::add_mainchain_segments() –> unsigned long

add_mainchain_segments_from_options(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → int

add segments between mainchain atoms using command line options

C++: protocols::backrub::BackrubMover::add_mainchain_segments_from_options() –> unsigned long

add_segment(*args, **kwargs)

Overloaded function.

1. add_segment(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, start_atomid: pyrosetta.rosetta.core.id.AtomID, end_atomid: pyrosetta.rosetta.core.id.AtomID) -> int
2. add_segment(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, start_atomid: pyrosetta.rosetta.core.id.AtomID, end_atomid: pyrosetta.rosetta.core.id.AtomID, max_angle_disp: float) -> int

add a segment to the mover

C++: protocols::backrub::BackrubMover::add_segment(class core::id::AtomID, class core::id::AtomID, double) –> unsigned long

apply(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::backrub::BackrubMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, : pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover

C++: protocols::canonical_sampling::ThermodynamicMover::operator=(const class protocols::canonical_sampling::ThermodynamicMover &) –> class protocols::canonical_sampling::ThermodynamicMover &

branchopt(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → pyrosetta.rosetta.protocols.branch_angle.BranchAngleOptimizer

get the branch angle optimizer stored in the mover

C++: protocols::backrub::BackrubMover::branchopt() –> class protocols::branch_angle::BranchAngleOptimizer &

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

clear_segments(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → None

remove all segements

C++: protocols::backrub::BackrubMover::clear_segments() –> void

clone(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::backrub::BackrubMover::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>

custom_angle(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → bool

get whether rotation angle is customized

C++: protocols::backrub::BackrubMover::custom_angle() const –> bool

finalize_simulation(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after all Monte Carlo trials are completed.

C++: protocols::canonical_sampling::ThermodynamicMover::finalize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

fresh_instance(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → pyrosetta.rosetta.protocols.moves.Mover

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

C++: protocols::backrub::BackrubMover::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

has_segment(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, start_atomid: pyrosetta.rosetta.core.id.AtomID, end_atomid: pyrosetta.rosetta.core.id.AtomID) → bool

determine whether a given segment exists

C++: protocols::backrub::BackrubMover::has_segment(class core::id::AtomID, class core::id::AtomID) –> bool

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

init_with_options(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → None

C++: protocols::backrub::BackrubMover::init_with_options() –> void

initialize_simulation(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, pose: pyrosetta.rosetta.core.pose.Pose, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover, cycle: int) → None

C++: protocols::backrub::BackrubMover::initialize_simulation(class core::pose::Pose &, const class protocols::canonical_sampling::MetropolisHastingsMover &, unsigned long) –> void

is_multi_trial(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → bool

Return true if the move performs multiple trials on each apply.

last_inner_score_delta_over_temperature()

metropolis_hastings_mover()

set_metropolis_hastings_mover()

C++: protocols::canonical_sampling::ThermodynamicMover::is_multi_trial() –> bool

last_angle(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → float

get the last rotation angle

C++: protocols::backrub::BackrubMover::last_angle() const –> double

last_end_atom_name(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → str

get the name of the atom at the end of the last segment

C++: protocols::backrub::BackrubMover::last_end_atom_name() const –> std::string

last_inner_score_delta_over_temperature(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → float

If this is a multi-trial move, return the change in internal

score/temperature caused by the last call to apply().

is_multi_trial()

C++: protocols::canonical_sampling::ThermodynamicMover::last_inner_score_delta_over_temperature() –> double

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → float

Return the proposal density ratio for last apply method.

C++: protocols::canonical_sampling::ThermodynamicMover::last_proposal_density_ratio() –> double

last_segment_id(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → int

get id the last backrub segment moved

C++: protocols::backrub::BackrubMover::last_segment_id() const –> unsigned long

last_start_atom_name(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → str

get the name of the atom at the start of the last segment

C++: protocols::backrub::BackrubMover::last_start_atom_name() const –> std::string

max_angle_disp_4(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → float

get maximum angular displacement for 4 atom segments

C++: protocols::backrub::BackrubMover::max_angle_disp_4() const –> double

max_angle_disp_7(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → float

get maximum angular displacement for 7 atom segments

C++: protocols::backrub::BackrubMover::max_angle_disp_7() const –> double

max_angle_disp_slope(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → float

get maximum angular displacement slope for other atom segments

C++: protocols::backrub::BackrubMover::max_angle_disp_slope() const –> double

max_atoms(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → int

get maximum segment length if no segments manually defined

C++: protocols::backrub::BackrubMover::max_atoms() const –> unsigned long

metropolis_hastings_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover) → pyrosetta.rosetta.std.weak_ptr_protocols_canonical_sampling_MetropolisHastingsMover_t

If this is a multi-trial move, return the MetropolisHastingsMover

being used internally.

is_multi_trial()

C++: protocols::canonical_sampling::ThermodynamicMover::metropolis_hastings_mover() –> class std::weak_ptr<class protocols::canonical_sampling::MetropolisHastingsMover>

min_atoms(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → int

get minimum segment length if no segments manually defined

C++: protocols::backrub::BackrubMover::min_atoms() const –> unsigned long

mover_name() → str

C++: protocols::backrub::BackrubMover::mover_name() –> std::string

name() → str

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

next_angle(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → float

get the rotation angle for the next move

C++: protocols::backrub::BackrubMover::next_angle() const –> double

next_segment_id(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → int

set the id for the next move (i.e. nonrandom)

C++: protocols::backrub::BackrubMover::next_segment_id() const –> unsigned long

num_segments(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → int

get the number of segments

C++: protocols::backrub::BackrubMover::num_segments() –> unsigned long

observe_after_metropolis(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, metropolis_hastings_mover: protocols::canonical_sampling::MetropolisHastingsMover) → None

Callback executed after the Metropolis criterion is evaluated.

C++: protocols::canonical_sampling::ThermodynamicMover::observe_after_metropolis(const class protocols::canonical_sampling::MetropolisHastingsMover &) –> void

optimize_branch_angles(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

optimize branching atoms for all segment pivot atoms

C++: protocols::backrub::BackrubMover::optimize_branch_angles(class core::pose::Pose &) –> void

pivot_atoms(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → pyrosetta.rosetta.utility.vector1_std_string

get atom names to pivot if no segments manually defined

C++: protocols::backrub::BackrubMover::pivot_atoms() const –> const class utility::vector1<std::string, class std::allocator<std::string > > &

pivot_residues(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → pyrosetta.rosetta.utility.vector1_unsigned_long

get residues to pivot if no segments manually defined

C++: protocols::backrub::BackrubMover::pivot_residues() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

preserve_detailed_balance(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → bool

get whether detailed balance is preserved (i.e. no branch angle optimization during moves)

C++: protocols::backrub::BackrubMover::preserve_detailed_balance() const –> bool

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

C++: protocols::backrub::BackrubMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

random_angle(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, pose: pyrosetta.rosetta.core.pose.Pose, segment_id: int, start_constants: pyrosetta.rosetta.utility.vector0_double, end_constants: pyrosetta.rosetta.utility.vector0_double) → float

get a random angle for a segment subject to bond angle and rotation constraints

C++: protocols::backrub::BackrubMover::random_angle(class core::pose::Pose &, unsigned long, class utility::vector0<double, class std::allocator<double> > &, class utility::vector0<double, class std::allocator<double> > &) –> double

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

require_mm_bend(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → bool

get whether to exit during initialize_simulation if the mm_bend term isn’t turned on

C++: protocols::backrub::BackrubMover::require_mm_bend() 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

rotate_segment(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, pose: pyrosetta.rosetta.core.pose.Pose, segment_id: int, angle: float, start_constants: pyrosetta.rosetta.utility.vector0_double, end_constants: pyrosetta.rosetta.utility.vector0_double) → None

do a manual rotation about the given segment

C++: protocols::backrub::BackrubMover::rotate_segment(class core::pose::Pose &, unsigned long, double, class utility::vector0<double, class std::allocator<double> > &, class utility::vector0<double, class std::allocator<double> > &) –> void

segment(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, segment_id: int) → pyrosetta.rosetta.protocols.backrub.BackrubSegment

get a particular segment

C++: protocols::backrub::BackrubMover::segment(unsigned long) –> const class protocols::backrub::BackrubSegment &

segment_id(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, start_atomid: pyrosetta.rosetta.core.id.AtomID, end_atomid: pyrosetta.rosetta.core.id.AtomID) → int

get the segment ID for a given starting and ending atom

if the segment ID does not exist, 0 is returned

C++: protocols::backrub::BackrubMover::segment_id(class core::id::AtomID, class core::id::AtomID) –> unsigned long

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_custom_angle(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, custom_angle: bool) → None

set whether rotation angle is customized

C++: protocols::backrub::BackrubMover::set_custom_angle(bool) –> 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_max_angle_disp_4(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, max_angle_disp_4: float) → None

set maximum angular displacement for 4 atom segments

C++: protocols::backrub::BackrubMover::set_max_angle_disp_4(double) –> void

set_max_angle_disp_7(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, max_angle_disp_7: float) → None

set maximum angular displacement for 7 atom segments

C++: protocols::backrub::BackrubMover::set_max_angle_disp_7(double) –> void

set_max_angle_disp_slope(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, max_angle_disp_slope: float) → None

set maximum angular displacement slope for other atom segments

C++: protocols::backrub::BackrubMover::set_max_angle_disp_slope(double) –> void

set_max_atoms(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, max_atoms: int) → None

set maximum segment length if no segments manually defined

C++: protocols::backrub::BackrubMover::set_max_atoms(unsigned long) –> void

set_metropolis_hastings_mover(self: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover, metropolis_hastings_mover: pyrosetta.rosetta.std.weak_ptr_protocols_canonical_sampling_MetropolisHastingsMover_t) → None

If this is a multi-trial move, set the MetropolisHastingsMover to

be used internally.

is_multi_trial()

C++: protocols::canonical_sampling::ThermodynamicMover::set_metropolis_hastings_mover(class std::weak_ptr<class protocols::canonical_sampling::MetropolisHastingsMover>) –> void

set_min_atoms(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, min_atoms: int) → None

set minimum segment length if no segments manually defined

C++: protocols::backrub::BackrubMover::set_min_atoms(unsigned long) –> void

set_movemap(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None

Sets Pivot Residues from the Movemap. Each contiguous set of residues

with BB enabled will be used as a segment.

C++: protocols::backrub::BackrubMover::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> 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_next_angle(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, next_angle: float) → None

set the rotation angle for the next move

C++: protocols::backrub::BackrubMover::set_next_angle(double) –> void

set_next_segment_id(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, next_segment_id: int) → None

set the id for the next move (i.e. nonrandom)

C++: protocols::backrub::BackrubMover::set_next_segment_id(unsigned long) –> void

set_pivot_atoms(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, pivot_atoms: pyrosetta.rosetta.utility.vector1_std_string) → None

set atom names to pivot if no segments manually defined

C++: protocols::backrub::BackrubMover::set_pivot_atoms(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

set_pivot_residues(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, pivot_residues: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

set residues to pivot if no segments manually defined

C++: protocols::backrub::BackrubMover::set_pivot_residues(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

set_preserve_detailed_balance(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, preserve_detailed_balance: bool) → None

set whether detailed balance is preserved (i.e. no branch angle optimization during moves)

C++: protocols::backrub::BackrubMover::set_preserve_detailed_balance(bool) –> void

set_require_mm_bend(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, require_mm_bend: bool) → None

set whether to exit during initialize_simulation if the mm_bend term isn’t turned on

C++: protocols::backrub::BackrubMover::set_require_mm_bend(bool) –> 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

torsion_id_ranges(self: pyrosetta.rosetta.protocols.backrub.BackrubMover, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_core_id_TorsionID_Range

get the TorsionIDs perturbed by the mover during moves, along with their ranges

C++: protocols::backrub::BackrubMover::torsion_id_ranges(class core::pose::Pose &) –> class utility::vector1<class core::id::TorsionID_Range, class std::allocator<class core::id::TorsionID_Range> >

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

update_type(self: pyrosetta.rosetta.protocols.backrub.BackrubMover) → None

update string describing the move type

C++: protocols::backrub::BackrubMover::update_type() –> void

class pyrosetta.rosetta.protocols.backrub.BackrubSegment

Bases: pybind11_builtins.pybind11_object

a class for holind information about individual backrub segments

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment, start_atomid: pyrosetta.rosetta.core.id.AtomID, start_atomid1: pyrosetta.rosetta.core.id.AtomID, start_atomid2: pyrosetta.rosetta.core.id.AtomID, end_atomid: pyrosetta.rosetta.core.id.AtomID, size: int, max_angle_disp: float) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

angle_disp(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment) → float

get overall angular displacement

C++: protocols::backrub::BackrubSegment::angle_disp() const –> double

end_atomid(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment) → pyrosetta.rosetta.core.id.AtomID

get AtomID of starting atom

C++: protocols::backrub::BackrubSegment::end_atomid() const –> class core::id::AtomID

end_atoms1(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment, pose: pyrosetta.rosetta.core.pose.Pose, end_atom_m1: pyrosetta.rosetta.core.kinematics.tree.Atom, end_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, end_atom_p1: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

get mainchain atom tree atoms 1 bond away from the end pivot

C++: protocols::backrub::BackrubSegment::end_atoms1(const class core::pose::Pose &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &) const –> void

end_atoms2(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment, pose: pyrosetta.rosetta.core.pose.Pose, end_atom_m2: pyrosetta.rosetta.core.kinematics.tree.Atom, end_atom_m1: pyrosetta.rosetta.core.kinematics.tree.Atom, end_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, end_atom_p1: pyrosetta.rosetta.core.kinematics.tree.Atom, end_atom_p2: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

get mainchain atom tree atoms 2 bonds away from the end pivot

C++: protocols::backrub::BackrubSegment::end_atoms2(const class core::pose::Pose &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &) const –> void

max_angle_disp(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment) → float

get maximum angular displacement

C++: protocols::backrub::BackrubSegment::max_angle_disp() const –> double

size(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment) → int

get the segment size

C++: protocols::backrub::BackrubSegment::size() const –> unsigned long

start_atomid(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment) → pyrosetta.rosetta.core.id.AtomID

get AtomID of starting atom

C++: protocols::backrub::BackrubSegment::start_atomid() const –> class core::id::AtomID

start_atomid1(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment) → pyrosetta.rosetta.core.id.AtomID

get AtomID of first atom along the path from start to end

C++: protocols::backrub::BackrubSegment::start_atomid1() const –> class core::id::AtomID

start_atomid2(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment) → pyrosetta.rosetta.core.id.AtomID

get AtomID of second atom along the path from start to end

C++: protocols::backrub::BackrubSegment::start_atomid2() const –> class core::id::AtomID

start_atoms1(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment, pose: pyrosetta.rosetta.core.pose.Pose, start_atom_m1: pyrosetta.rosetta.core.kinematics.tree.Atom, start_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, start_atom_p1: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

get mainchain atom tree atoms 1 bond away from the start pivot

C++: protocols::backrub::BackrubSegment::start_atoms1(const class core::pose::Pose &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &) const –> void

start_atoms2(self: pyrosetta.rosetta.protocols.backrub.BackrubSegment, pose: pyrosetta.rosetta.core.pose.Pose, start_atom_m2: pyrosetta.rosetta.core.kinematics.tree.Atom, start_atom_m1: pyrosetta.rosetta.core.kinematics.tree.Atom, start_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, start_atom_p1: pyrosetta.rosetta.core.kinematics.tree.Atom, start_atom_p2: pyrosetta.rosetta.core.kinematics.tree.Atom) → None

get mainchain atom tree atoms 2 bonds away from the start pivot

C++: protocols::backrub::BackrubSegment::start_atoms2(const class core::pose::Pose &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &, class std::shared_ptr<const class core::kinematics::tree::Atom> &) const –> void

pyrosetta.rosetta.protocols.backrub.append_fold_tree_to_file(foldtree: pyrosetta.rosetta.core.kinematics.FoldTree, file_path: str) → None

C++: protocols::backrub::append_fold_tree_to_file(const class core::kinematics::FoldTree &, class std::basic_string<char>) –> void

pyrosetta.rosetta.protocols.backrub.backrub_rotation_angles(constants: pyrosetta.rosetta.utility.vector0_double, tau: float, bondange: float, torsion1: float, torsion2: float) → None

calculate internal coordinate values for any tau value

C++: protocols::backrub::backrub_rotation_angles(const class utility::vector0<double, class std::allocator<double> > &, const double, double &, double &, double &) –> void

pyrosetta.rosetta.protocols.backrub.backrub_rotation_constants(*args, **kwargs)

Overloaded function.

1. backrub_rotation_constants(PM2_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PM1_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, P_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PP1_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PP2_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, REF_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, constants: pyrosetta.rosetta.utility.vector0_double) -> None
2. backrub_rotation_constants(PM2_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PM1_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, P_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PP1_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PP2_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, REF_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, constants: pyrosetta.rosetta.utility.vector0_double, alpha_min: float) -> None
3. backrub_rotation_constants(PM2_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PM1_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, P_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PP1_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PP2_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, REF_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, constants: pyrosetta.rosetta.utility.vector0_double, alpha_min: float, alpha_max: float) -> None
4. backrub_rotation_constants(PM2_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PM1_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, P_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PP1_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, PP2_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, REF_atom: pyrosetta.rosetta.core.kinematics.tree.Atom, constants: pyrosetta.rosetta.utility.vector0_double, alpha_min: float, alpha_max: float, tau_intervals: pyrosetta.rosetta.numeric.IntervalSet_double_t) -> None

calculate constants necessary for calculating internal angles/derivatives

C++: protocols::backrub::backrub_rotation_constants(class std::shared_ptr<const class core::kinematics::tree::Atom>, class std::shared_ptr<const class core::kinematics::tree::Atom>, class std::shared_ptr<const class core::kinematics::tree::Atom>, class std::shared_ptr<const class core::kinematics::tree::Atom>, class std::shared_ptr<const class core::kinematics::tree::Atom>, class std::shared_ptr<const class core::kinematics::tree::Atom>, class utility::vector0<double, class std::allocator<double> > &, const double, const double, class numeric::IntervalSet<double> *) –> void

pyrosetta.rosetta.protocols.backrub.get_pivot_residues_from_movemap(movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::backrub::get_pivot_residues_from_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.protocols.backrub.positions_incompatible_with_task(pose: pyrosetta.rosetta.core.pose.Pose, packertask: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::backrub::positions_incompatible_with_task(class core::pose::Pose &, class core::pack::task::PackerTask &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.protocols.backrub.read_fold_tree_from_file(*args, **kwargs)

Overloaded function.

1. read_fold_tree_from_file(foldtree: pyrosetta.rosetta.core.kinematics.FoldTree, filepath: str) -> bool

C++: protocols::backrub::read_fold_tree_from_file(class core::kinematics::FoldTree &, class std::basic_string<char>) –> bool

2. read_fold_tree_from_file(pose: pyrosetta.rosetta.core.pose.Pose, filepath: str) -> bool

C++: protocols::backrub::read_fold_tree_from_file(class core::pose::Pose &, class std::basic_string<char>) –> bool