kinematic_closure

• perturbers
• pivot_pickers
• solution_pickers

Bindings for protocols::kinematic_closure namespace

class pyrosetta.rosetta.protocols.kinematic_closure.BalancedKicMover

Bases: pyrosetta.rosetta.protocols.canonical_sampling.ThermodynamicMover

Make a kinematic closure move that obeys detailed balance.

This class is very conceptually similar to KicMover, so check out its documentation for a general overview of the kinematic closure algorithm. Here I will just highlight some details associated with making a balanced version of the move. Detailed balance is a useful property, because it allows a Monte Carlo simulation to recapitulate ensembles with correct equilibrium populations (so long as sampling is good, of course). There are a two reasons why the standard KicMover algorithm does not obey detailed balance. The first is that the geometry of the closure move itself introduces some inherent bias which has to be explicitly canceled out. The second is that care needs to be taken to perturb the non-pivot torsions in a way that also obeys detailed balance, as well.

The add_perturber() method works much like it does in KicMover. The only conceptual difference is that when the added perturbers are used internally within apply(), perturbers::Perturber::perturb_with_balance() is called instead of perturbers::Perturber::perturb(). This makes it easy to make variants of the perturber algorithms which obey detailed balance. The set_pivot_picker() method is no different from the KicMover version.

__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.kinematic_closure.BalancedKicMover) → 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_perturber(self: pyrosetta.rosetta.protocols.kinematic_closure.BalancedKicMover, perturber: protocols::kinematic_closure::perturbers::Perturber) → None

KicMover::add_perturber

C++: protocols::kinematic_closure::BalancedKicMover::add_perturber(class std::shared_ptr<class protocols::kinematic_closure::perturbers::Perturber>) –> void

apply(self: pyrosetta.rosetta.protocols.kinematic_closure.BalancedKicMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

KicMover::apply

C++: protocols::kinematic_closure::BalancedKicMover::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 &

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

Return a clone of the Mover object.

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

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::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.kinematic_closure.BalancedKicMover) → str

KicMover::get_name

C++: protocols::kinematic_closure::BalancedKicMover::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 > > &

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

Callback executed before any Monte Carlo trials are attempted.

C++: protocols::canonical_sampling::ThermodynamicMover::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

is_solution_trivial(problem: protocols::kinematic_closure::ClosureProblem, solution: protocols::kinematic_closure::ClosureSolution, unperturbed_solutions: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_kinematic_closure_ClosureSolution_t, perturbed_solutions: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_kinematic_closure_ClosureSolution_t) → bool

Return true if the given solution is the same as the input pose.

This allows for a more accurate reporting of Monte Carlo statistics.

C++: protocols::kinematic_closure::BalancedKicMover::is_solution_trivial(class std::shared_ptr<const class protocols::kinematic_closure::ClosureProblem>, class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution>, const class utility::vector1<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution>, class std::allocator<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution> > > &, const class utility::vector1<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution>, class std::allocator<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution> > > &) –> bool

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.kinematic_closure.BalancedKicMover) → float

Right now the proposal probabilities are balanced internally, so

this ratio will always be unity. This could change eventually, though.

C++: protocols::kinematic_closure::BalancedKicMover::last_proposal_density_ratio() –> double

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>

name() → str

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

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

pick_solution(unperturbed_solutions: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_kinematic_closure_ClosureSolution_t, perturbed_solutions: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_kinematic_closure_ClosureSolution_t) → protocols::kinematic_closure::ClosureSolution

Pick a solution in a way that cancels out the geometrical bias of

the kinematic closure algorithm.

C++: protocols::kinematic_closure::BalancedKicMover::pick_solution(const class utility::vector1<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution>, class std::allocator<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution> > > &, const class utility::vector1<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution>, class std::allocator<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution> > > &) –> class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution>

preserve_detailed_balance(self: pyrosetta.rosetta.protocols.kinematic_closure.BalancedKicMover) → bool

Return true, because this mover always obeys detailed balance.

C++: protocols::kinematic_closure::BalancedKicMover::preserve_detailed_balance() const –> bool

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_loop(self: pyrosetta.rosetta.protocols.kinematic_closure.BalancedKicMover, loop: pyrosetta.rosetta.protocols.loops.Loop) → None

KicMover::set_loop

C++: protocols::kinematic_closure::BalancedKicMover::set_loop(const class protocols::loops::Loop &) –> 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_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_pivot_picker(self: pyrosetta.rosetta.protocols.kinematic_closure.BalancedKicMover, picker: protocols::kinematic_closure::pivot_pickers::PivotPicker) → None

KicMover::set_pivot_picker

C++: protocols::kinematic_closure::BalancedKicMover::set_pivot_picker(class std::shared_ptr<class protocols::kinematic_closure::pivot_pickers::PivotPicker>) –> void

set_preserve_detailed_balance(self: pyrosetta.rosetta.protocols.kinematic_closure.BalancedKicMover, : bool) → None

This mover always obeys detailed balance, so this is a no-op.

C++: protocols::kinematic_closure::BalancedKicMover::set_preserve_detailed_balance(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.kinematic_closure.BalancedKicMover, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_core_id_TorsionID_Range

Indicate that each torsion in the loop may take on any value.

C++: protocols::kinematic_closure::BalancedKicMover::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

class pyrosetta.rosetta.protocols.kinematic_closure.ChainedSolutionList

Bases: pybind11_builtins.pybind11_object

Iterate sequentially through two solution lists.

This functionality is very important to the balanced solution picker. While it could be done without this class (basically by doubling the number of for-loops) I think that this class meaningfully improves the readability of the code.

__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.kinematic_closure.ChainedSolutionList, a: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_kinematic_closure_ClosureSolution_t, b: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_kinematic_closure_ClosureSolution_t) → 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).

back(self: pyrosetta.rosetta.protocols.kinematic_closure.ChainedSolutionList) → pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution

C++: protocols::kinematic_closure::ChainedSolutionList::back() –> const class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution>

begin(self: pyrosetta.rosetta.protocols.kinematic_closure.ChainedSolutionList) → protocols::kinematic_closure::ChainedSolutionList::Iterator

C++: protocols::kinematic_closure::ChainedSolutionList::begin() –> class protocols::kinematic_closure::ChainedSolutionList::Iterator

empty(self: pyrosetta.rosetta.protocols.kinematic_closure.ChainedSolutionList) → bool

C++: protocols::kinematic_closure::ChainedSolutionList::empty() –> bool

end(self: pyrosetta.rosetta.protocols.kinematic_closure.ChainedSolutionList) → protocols::kinematic_closure::ChainedSolutionList::Iterator

C++: protocols::kinematic_closure::ChainedSolutionList::end() –> class protocols::kinematic_closure::ChainedSolutionList::Iterator

front(self: pyrosetta.rosetta.protocols.kinematic_closure.ChainedSolutionList) → pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution

C++: protocols::kinematic_closure::ChainedSolutionList::front() –> const class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution>

not_empty(self: pyrosetta.rosetta.protocols.kinematic_closure.ChainedSolutionList) → bool

C++: protocols::kinematic_closure::ChainedSolutionList::not_empty() –> bool

size(self: pyrosetta.rosetta.protocols.kinematic_closure.ChainedSolutionList) → bool

C++: protocols::kinematic_closure::ChainedSolutionList::size() –> bool

class pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem

Bases: pybind11_builtins.pybind11_object

Represent and solve a kinematic closure problem.

A number of parameters are needed to define a kinematic closure problem. These parameters include a region of the protein backbone, a set of pivot residues, and a new set of torsion angles for the nonpivot residues. All of this can be specified using the frame() and methods. Once that has been done, the solve() method can be called to return the complete set of backbone conformations consistent with the given parameters. These conformations are represented by the ClosureSolution class. The restore() method can be used to undo a solution once it has been applied, which is useful in some Monte Carlo schemes.

__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.kinematic_closure.ClosureProblem) → 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).

c_n(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int) → float

Return the current value of the given C-N bond length.

C++: protocols::kinematic_closure::ClosureProblem::c_n(unsigned long) const –> double

c_n_ca(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → float

Return the current value of the given C-N-CA bond angle.

C++: protocols::kinematic_closure::ClosureProblem::c_n_ca(unsigned long, enum numeric::conversions::AngleUnit) const –> double

ca_c(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int) → float

Return the current value of the given CA-C bond length.

C++: protocols::kinematic_closure::ClosureProblem::ca_c(unsigned long) const –> double

ca_c_n(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → float

Return the current value of the given CA-C-N bond angle.

C++: protocols::kinematic_closure::ClosureProblem::ca_c_n(unsigned long, enum numeric::conversions::AngleUnit) const –> double

cut_residue(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → int

Return the index of the second pivot residue.

C++: protocols::kinematic_closure::ClosureProblem::cut_residue() const –> unsigned long

first_residue(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → int

Return the index of the first pivot residue.

C++: protocols::kinematic_closure::ClosureProblem::first_residue() const –> unsigned long

frame(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop, pivot_picker: protocols::kinematic_closure::pivot_pickers::PivotPicker) → None

Choose pivots and copy coordinate information into the problem.

C++: protocols::kinematic_closure::ClosureProblem::frame(const class core::pose::Pose &, const class protocols::loops::Loop &, class std::shared_ptr<class protocols::kinematic_closure::pivot_pickers::PivotPicker>) –> void

is_nonpivot_residue(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int) → bool

Return true if the given residue is not a pivot.

C++: protocols::kinematic_closure::ClosureProblem::is_nonpivot_residue(unsigned long) const –> bool

is_pivot_residue(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int) → bool

Return true if the given residue is a pivot.

C++: protocols::kinematic_closure::ClosureProblem::is_pivot_residue(unsigned long) const –> bool

last_residue(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → int

Return the index of the third pivot residue.

C++: protocols::kinematic_closure::ClosureProblem::last_residue() const –> unsigned long

n_ca(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int) → float

Return the current value of the given N-CA bond length.

C++: protocols::kinematic_closure::ClosureProblem::n_ca(unsigned long) const –> double

n_ca_c(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → float

Return the current value of the given N-CA-C bond angle.

C++: protocols::kinematic_closure::ClosureProblem::n_ca_c(unsigned long, enum numeric::conversions::AngleUnit) const –> double

nonpivot_residues(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return the indices of every nonpivot residue in the loop.

C++: protocols::kinematic_closure::ClosureProblem::nonpivot_residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

num_atoms(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → int

Return the number of atoms in the loop.

C++: protocols::kinematic_closure::ClosureProblem::num_atoms() const –> unsigned long

num_residues(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → int

Return the number of residues in the loop.

C++: protocols::kinematic_closure::ClosureProblem::num_residues() const –> unsigned long

omega(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → float

Return the current value of the given omega angle.

C++: protocols::kinematic_closure::ClosureProblem::omega(unsigned long, enum numeric::conversions::AngleUnit) const –> double

perturb_angles(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.utility.vector1_double

Provide non-const access to the raw bond angle list.

C++: protocols::kinematic_closure::ClosureProblem::perturb_angles() –> class utility::vector1<double, class std::allocator<double> > &

perturb_c_n(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, value: float) → None

Perturb the C-N bond length in the given residue.

C++: protocols::kinematic_closure::ClosureProblem::perturb_c_n(unsigned long, double) –> void

perturb_c_n_ca(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, value: float, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → None

Perturb the C-N-CA bond angle in the given residue.

C++: protocols::kinematic_closure::ClosureProblem::perturb_c_n_ca(unsigned long, double, enum numeric::conversions::AngleUnit) –> void

perturb_ca_c(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, value: float) → None

Perturb the CA-C bond length in the given residue.

C++: protocols::kinematic_closure::ClosureProblem::perturb_ca_c(unsigned long, double) –> void

perturb_ca_c_n(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, value: float, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → None

Perturb the CA-C-N bond angle in the given residue.

C++: protocols::kinematic_closure::ClosureProblem::perturb_ca_c_n(unsigned long, double, enum numeric::conversions::AngleUnit) –> void

perturb_lengths(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.utility.vector1_double

Provide non-const access to the raw bond length list.

C++: protocols::kinematic_closure::ClosureProblem::perturb_lengths() –> class utility::vector1<double, class std::allocator<double> > &

perturb_n_ca(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, value: float) → None

Perturb the N-CA bond length in the given residue.

C++: protocols::kinematic_closure::ClosureProblem::perturb_n_ca(unsigned long, double) –> void

perturb_n_ca_c(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, value: float, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → None

Perturb the N-CA-C bond angle in the given residue.

C++: protocols::kinematic_closure::ClosureProblem::perturb_n_ca_c(unsigned long, double, enum numeric::conversions::AngleUnit) –> void

perturb_omega(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, value: float, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → None

Perturb the given omega angle.

C++: protocols::kinematic_closure::ClosureProblem::perturb_omega(unsigned long, double, enum numeric::conversions::AngleUnit) –> void

perturb_phi(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, value: float, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → None

Perturb the given phi angle.

C++: protocols::kinematic_closure::ClosureProblem::perturb_phi(unsigned long, double, enum numeric::conversions::AngleUnit) –> void

perturb_psi(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, value: float, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → None

Perturb the given psi angle.

C++: protocols::kinematic_closure::ClosureProblem::perturb_psi(unsigned long, double, enum numeric::conversions::AngleUnit) –> void

perturb_torsions(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.utility.vector1_double

Provide non-const access to the raw torsion angle list.

C++: protocols::kinematic_closure::ClosureProblem::perturb_torsions() –> class utility::vector1<double, class std::allocator<double> > &

perturbed_sequence(*args, **kwargs)

Overloaded function.

1. perturbed_sequence(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, values: pyrosetta.rosetta.utility.vector1_std_string) -> None

Set AA sequence from left pivot to the right pivot (including the pivots)

C++: protocols::kinematic_closure::ClosureProblem::perturbed_sequence(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

2. perturbed_sequence(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) -> pyrosetta.rosetta.utility.vector1_std_string

Get perturbed AA sequence from left pivot to the right pivot (including the pivots)

C++: protocols::kinematic_closure::ClosureProblem::perturbed_sequence() const –> class utility::vector1<std::string, class std::allocator<std::string > >

phi(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → float

Return the current value of the given phi angle.

C++: protocols::kinematic_closure::ClosureProblem::phi(unsigned long, enum numeric::conversions::AngleUnit) const –> double

pivot_atoms(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return the indices of all three pivot atoms.

C++: protocols::kinematic_closure::ClosureProblem::pivot_atoms() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pivot_loop(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.protocols.loops.Loop

Return a loop specifying the three pivot residues.

C++: protocols::kinematic_closure::ClosureProblem::pivot_loop() const –> class protocols::loops::Loop

pivot_residues(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return the indices of all three pivot residues.

C++: protocols::kinematic_closure::ClosureProblem::pivot_residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

psi(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, residue: int, unit: pyrosetta.rosetta.numeric.conversions.AngleUnit) → float

Return the current value of the given psi angle.

C++: protocols::kinematic_closure::ClosureProblem::psi(unsigned long, enum numeric::conversions::AngleUnit) const –> double

residues(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.utility.vector1_unsigned_long

Return the indices of every residue in the loop.

C++: protocols::kinematic_closure::ClosureProblem::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

restore(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem, pose: pyrosetta.rosetta.core.pose.Pose) → None

Undo any changes made to the pose during the last move.

C++: protocols::kinematic_closure::ClosureProblem::restore(class core::pose::Pose &) const –> void

sequence_mutated(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → bool

Return if mutations have been made to the sequence

C++: protocols::kinematic_closure::ClosureProblem::sequence_mutated() const –> bool

solve(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_kinematic_closure_ClosureSolution_t

Return every possible solution to this problem.

C++: protocols::kinematic_closure::ClosureProblem::solve() const –> class utility::vector1<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution>, class std::allocator<class std::shared_ptr<const class protocols::kinematic_closure::ClosureSolution> > >

unperturbed_sequence(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → pyrosetta.rosetta.utility.vector1_std_string

Get unperturbed AA sequence from left pivot to the right pivot (including the pivots)

C++: protocols::kinematic_closure::ClosureProblem::unperturbed_sequence() const –> class utility::vector1<std::string, class std::allocator<std::string > >

class pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution

Bases: pybind11_builtins.pybind11_object

Represent a single solution to a kinematic closure problem.

The ClosureSolution class represents the solutions returned by ClosureProblem.solve(). The most important methods of this class are apply() and apply_if_reasonable(). The former unconditionally applies the solution to the given pose, while the latter does so only if the solution passes a rama and bump check.

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

Initialize self. See help(type(self)) for accurate signature.

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

apply(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution, pose: pyrosetta.rosetta.core.pose.Pose) → None

Apply this solution to the given pose.

C++: protocols::kinematic_closure::ClosureSolution::apply(class core::pose::Pose &) const –> void

apply_if_reasonable(*args, **kwargs)

Overloaded function.

1. apply_if_reasonable(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution, pose: pyrosetta.rosetta.core.pose.Pose) -> bool
2. apply_if_reasonable(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution, pose: pyrosetta.rosetta.core.pose.Pose, rama_on: bool) -> bool
3. apply_if_reasonable(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution, pose: pyrosetta.rosetta.core.pose.Pose, rama_on: bool, bump_on: bool) -> bool
4. apply_if_reasonable(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution, pose: pyrosetta.rosetta.core.pose.Pose, rama_on: bool, bump_on: bool, be_lenient: bool) -> bool

If this solution passes rama and bump checks, apply it to the

given pose. Return whether or not the filters were passed.

C++: protocols::kinematic_closure::ClosureSolution::apply_if_reasonable(class core::pose::Pose &, bool, bool, bool) const –> bool

get_distance(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution, problem: pyrosetta.rosetta.protocols.kinematic_closure.ClosureProblem) → float

@ brief Return a distance metric indicating how similar this solution

is to the given problem.

C++: protocols::kinematic_closure::ClosureSolution::get_distance(const class protocols::kinematic_closure::ClosureProblem *) const –> double

get_index(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution) → int

Return a unique number identifying this solution.

C++: protocols::kinematic_closure::ClosureSolution::get_index() const –> unsigned long

get_jacobian(self: pyrosetta.rosetta.protocols.kinematic_closure.ClosureSolution) → float

Return the Jacobian for this solution.

C++: protocols::kinematic_closure::ClosureSolution::get_jacobian() const –> double

class pyrosetta.rosetta.protocols.kinematic_closure.IdealParameters

Bases: pybind11_builtins.pybind11_object

Catalog ideal geometries for a number of different lengths, angles, and torsions.

This class should definitely not exist. It is basically just a bunch of magic numbers that must exist somewhere in the database already. Unfortunately, I can’t find them and so we’re stuck with this nonsense.

__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.kinematic_closure.IdealParameters) → 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).

class pyrosetta.rosetta.protocols.kinematic_closure.KicMover

Bases: pyrosetta.rosetta.protocols.loop_modeling.LoopMover

Find a new backbone conformation for some region of a protein.

The first step in the kinematic closure algorithm is to pick a loop and three pivot residues. Any residues in the loop that are not pivots are called non-pivots. The non-pivot backbone torsions are used to make new conformations, while the pivot torsions are used to ensure that the backbone stays closed. Use set_loops() to specify loops to sample. Use set_pivot_picker() to specify how the pivots should be chosen. Use add_perturber() to specify how the non-pivots should be sampled. By default, the algorithm will pick pivots randomly within the region being sampled and will sample the non-pivot torsions from a rama distribution.

Given a set of pivot residues and nonpivot torsion angles, the algorithm will find up to 16 possible solutions. The set_solution_picker() method allows you to control which solution, if any, is picked. By default, the first solution found which passes both a rama and a bump check is used.

The default kinematic closure algorithm samples both pivot and nonpivot torsions from a rama distribution. Because this algorithm is often used in situations where the score function also contains a rama term, the rama bias is usually double-counted. This is bad, because it means that backbone torsions are normally sampled too narrowly. There are two proper ways to deal with this, but they both have drawbacks. The first would be to sample from a uniform distribution and to let the score function take care of preferring angles that fit the rama distribution. Unfortunately, this would be much less efficient than the current approach, primarily because the rama check is fast and filters out a lot of bad solutions. The second approach would be to sample from a rama distribution and to remove the rama term from the score function. This would be even more efficient than the current approach, but it would be prone to bugs because other parts of the code wouldn’t expect the score function to be changing on every invocation of KIC.

Once the algorithm has been setup using the helper methods described above, apply() can be called to actually sample a new backbone conformation.

__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.kinematic_closure.KicMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover, arg0: pyrosetta.rosetta.protocols.kinematic_closure.KicMover) -> 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_perturber(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover, perturber: protocols::kinematic_closure::perturbers::Perturber) → None

Specify how the non-pivot torsions should be sampled.

C++: protocols::kinematic_closure::KicMover::add_perturber(class std::shared_ptr<class protocols::kinematic_closure::perturbers::Perturber>) –> void

apply(self: pyrosetta.rosetta.protocols.loop_modeling.LoopMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Sample the pose in the regions specified by get_loops().

The parent class apply() method automatically sets up a fold tree (if necessary) and keeps track of whether or not the move succeeded. Child classes should reimplement do_apply() instead of this method.

C++: protocols::loop_modeling::LoopMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover, : pyrosetta.rosetta.protocols.kinematic_closure.KicMover) → pyrosetta.rosetta.protocols.kinematic_closure.KicMover

C++: protocols::kinematic_closure::KicMover::operator=(const class protocols::kinematic_closure::KicMover &) –> class protocols::kinematic_closure::KicMover &

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_perturbers(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover) → None

Forget any perturbers that had been previously added.

C++: protocols::kinematic_closure::KicMover::clear_perturbers() –> void

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

Return a clone of the Mover object.

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

define_composition_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, ct_gen: pyrosetta.rosetta.utility.tag.XMLSchemaComplexTypeGenerator, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → None

C++: protocols::loop_modeling::LoopMover::define_composition_schema(class utility::tag::XMLSchemaDefinition &, class utility::tag::XMLSchemaComplexTypeGenerator &, class utility::tag::XMLSchemaSimpleSubelementList &) –> void

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

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::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_children_names(*args, **kwargs)

Overloaded function.

1. get_children_names(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover, names: pyrosetta.rosetta.utility.vector1_std_string) -> None
2. get_children_names(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover, names: pyrosetta.rosetta.utility.vector1_std_string, indent: str) -> None

LoopMover::get_children_names

C++: protocols::kinematic_closure::KicMover::get_children_names(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, class std::basic_string<char>) const –> void

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob

C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

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

A tag is a unique identifier used to identify structures produced

by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

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

get_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_loop(self: pyrosetta.rosetta.protocols.loop_modeling.LoopMover, index: int) → pyrosetta.rosetta.protocols.loops.Loop

Return the specified loop.

C++: protocols::loop_modeling::LoopMover::get_loop(unsigned long) const –> const class protocols::loops::Loop &

get_loops(self: pyrosetta.rosetta.protocols.loop_modeling.LoopMover) → pyrosetta.rosetta.protocols.loops.Loops

Return the loops to be sampled on the next call to apply().

C++: protocols::loop_modeling::LoopMover::get_loops() –> class std::shared_ptr<class protocols::loops::Loops>

get_name(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover) → str

C++: protocols::kinematic_closure::KicMover::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_pivot_picker(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover) → protocols::kinematic_closure::pivot_pickers::PivotPicker

Return the PivotPicker being used by this mover.

C++: protocols::kinematic_closure::KicMover::get_pivot_picker() –> class std::shared_ptr<class protocols::kinematic_closure::pivot_pickers::PivotPicker>

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_solution_picker(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover) → protocols::kinematic_closure::solution_pickers::SolutionPicker

Return the SolutionPicker being used by this mover.

C++: protocols::kinematic_closure::KicMover::get_solution_picker() –> class std::shared_ptr<class protocols::kinematic_closure::solution_pickers::SolutionPicker>

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

mover_name() → str

C++: protocols::kinematic_closure::KicMover::mover_name() –> std::string

name() → str

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

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

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

request_fold_tree(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover) → pyrosetta.rosetta.protocols.loop_modeling.FoldTreeRequest

LoopMover::request_fold_tree

C++: protocols::kinematic_closure::KicMover::request_fold_tree() const –> enum protocols::loop_modeling::FoldTreeRequest

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_loop(self: pyrosetta.rosetta.protocols.loop_modeling.LoopMover, loop: pyrosetta.rosetta.protocols.loops.Loop) → None

Set the loop to be sampled on the next call to apply().

C++: protocols::loop_modeling::LoopMover::set_loop(const class protocols::loops::Loop &) –> void

set_loops(*args, **kwargs)

Overloaded function.

1. set_loops(self: pyrosetta.rosetta.protocols.loop_modeling.LoopMover, loops: pyrosetta.rosetta.protocols.loops.Loops) -> None

Set the loops to be sampled on the next call to apply().

C++: protocols::loop_modeling::LoopMover::set_loops(class std::shared_ptr<class protocols::loops::Loops>) –> void

2. set_loops(self: pyrosetta.rosetta.protocols.loop_modeling.LoopMover, loops: pyrosetta.rosetta.protocols.loops.Loops) -> None

Set the loops to be sampled on the next call to apply().

C++: protocols::loop_modeling::LoopMover::set_loops(const class protocols::loops::Loops &) –> 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_pivot_picker(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover, picker: protocols::kinematic_closure::pivot_pickers::PivotPicker) → None

Specify how the pivot residues should be chosen.

C++: protocols::kinematic_closure::KicMover::set_pivot_picker(class std::shared_ptr<class protocols::kinematic_closure::pivot_pickers::PivotPicker>) –> void

set_solution_picker(self: pyrosetta.rosetta.protocols.kinematic_closure.KicMover, picker: protocols::kinematic_closure::solution_pickers::SolutionPicker) → None

Specify how a solution should be chosen.

C++: protocols::kinematic_closure::KicMover::set_solution_picker(class std::shared_ptr<class protocols::kinematic_closure::solution_pickers::SolutionPicker>) –> 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

setup_fold_tree(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops, request: pyrosetta.rosetta.protocols.loop_modeling.FoldTreeRequest) → None

Setup the given pose with a fold tree that is compatible with the

given loops and requests.

C++: protocols::loop_modeling::LoopMover::setup_fold_tree(class core::pose::Pose &, class std::shared_ptr<const class protocols::loops::Loops>, enum protocols::loop_modeling::FoldTreeRequest) –> 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

trust_fold_tree(self: pyrosetta.rosetta.protocols.loop_modeling.LoopMover) → None

Promise that the calling code will setup a fold tree compatible

with request_fold_tree(). If this method is not called, this mover will setup a fold tree on its own every time apply() is called.

C++: protocols::loop_modeling::LoopMover::trust_fold_tree() –> 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

was_successful(*args, **kwargs)

Overloaded function.

1. was_successful(self: pyrosetta.rosetta.protocols.loop_modeling.LoopMover) -> bool

Return true if the previous move was successful.

C++: protocols::loop_modeling::LoopMover::was_successful() const –> bool

2. was_successful(self: pyrosetta.rosetta.protocols.loop_modeling.LoopMover, value: bool) -> None

Set the success status of a loop mover

C++: protocols::loop_modeling::LoopMover::was_successful(bool) –> void