moves

Bindings for protocols::moves namespace

pyrosetta.rosetta.protocols.moves.AddPyMOLObserver(*args, **kwargs)

Overloaded function.

1. AddPyMOLObserver(p: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.moves.PyMOLObserver
2. AddPyMOLObserver(p: pyrosetta.rosetta.core.pose.Pose, keep_history: bool) -> pyrosetta.rosetta.protocols.moves.PyMOLObserver
3. AddPyMOLObserver(p: pyrosetta.rosetta.core.pose.Pose, keep_history: bool, update_interval: float) -> pyrosetta.rosetta.protocols.moves.PyMOLObserver

Helper function that create PyMOLObserver Object and add it to the give Pose.

This is the most likely the only function that you need to call…

C++: protocols::moves::AddPyMOLObserver(class core::pose::Pose &, bool, double) –> class std::shared_ptr<class protocols::moves::PyMOLObserver>

pyrosetta.rosetta.protocols.moves.AddPyMOLObserver_to_conformation(*args, **kwargs)

Overloaded function.

1. AddPyMOLObserver_to_conformation(p: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.moves.PyMOLObserver
2. AddPyMOLObserver_to_conformation(p: pyrosetta.rosetta.core.pose.Pose, keep_history: bool) -> pyrosetta.rosetta.protocols.moves.PyMOLObserver
3. AddPyMOLObserver_to_conformation(p: pyrosetta.rosetta.core.pose.Pose, keep_history: bool, update_interval: float) -> pyrosetta.rosetta.protocols.moves.PyMOLObserver

Helper function that create PyMOLObserver Object and add it to the give Pose conformation object so pymol only updates on conformation changes.

C++: protocols::moves::AddPyMOLObserver_to_conformation(class core::pose::Pose &, bool, double) –> class std::shared_ptr<class protocols::moves::PyMOLObserver>

pyrosetta.rosetta.protocols.moves.AddPyMOLObserver_to_energies(*args, **kwargs)

Overloaded function.

1. AddPyMOLObserver_to_energies(p: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.moves.PyMOLObserver
2. AddPyMOLObserver_to_energies(p: pyrosetta.rosetta.core.pose.Pose, keep_history: bool) -> pyrosetta.rosetta.protocols.moves.PyMOLObserver
3. AddPyMOLObserver_to_energies(p: pyrosetta.rosetta.core.pose.Pose, keep_history: bool, update_interval: float) -> pyrosetta.rosetta.protocols.moves.PyMOLObserver

Helper function that create PyMOLObserver Object and add it to the give Pose energies object so pymol only updates on energy changes.

C++: protocols::moves::AddPyMOLObserver_to_energies(class core::pose::Pose &, bool, double) –> class std::shared_ptr<class protocols::moves::PyMOLObserver>

class pyrosetta.rosetta.protocols.moves.CycleMover

Bases: pyrosetta.rosetta.protocols.moves.MoverContainer

CycleMover iterates through its vector of Movers one at a time over many calls to apply().

Each time CycleMover.apply() is called, it calls apply() on the next Mover in its sequence,

until reaching the end of the list and starting over. Useful for things like doing a full repack one out of every eight cycles, and a rotamer trials on the other seven.

add_mover(*args, **kwargs)

Overloaded function.

1. add_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, mover_in: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. add_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, mover_in: pyrosetta.rosetta.protocols.moves.Mover, weight_in: float) -> None

Adds a mover to the end of this container

C++: protocols::moves::MoverContainer::add_mover(class std::shared_ptr<class protocols::moves::Mover>, double) –> void

apply(self: pyrosetta.rosetta.protocols.moves.CycleMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::CycleMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.CycleMover, : pyrosetta.rosetta.protocols.moves.CycleMover) → pyrosetta.rosetta.protocols.moves.CycleMover

C++: protocols::moves::CycleMover::operator=(const class protocols::moves::CycleMover &) –> class protocols::moves::CycleMover &

clear(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → None

C++: protocols::moves::MoverContainer::clear() –> void

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

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

Clone returns a new instance of CycleMover representing a deep copy of this mover.

C++: protocols::moves::CycleMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

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

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

front(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::MoverContainer::front() –> 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_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, index: int) → str

C++: protocols::moves::MoverContainer::get_mover(unsigned long) const –> std::string

get_name(self: pyrosetta.rosetta.protocols.moves.CycleMover) → str

C++: protocols::moves::CycleMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

movers(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.utility.vector0_std_shared_ptr_protocols_moves_Mover_t

C++: protocols::moves::MoverContainer::movers() const –> const class utility::vector0<class std::shared_ptr<class protocols::moves::Mover>, class std::allocator<class std::shared_ptr<class protocols::moves::Mover> > > &

name() → str

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

nr_moves(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → int

C++: protocols::moves::MoverContainer::nr_moves() –> unsigned long

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

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

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_cycle_index(self: pyrosetta.rosetta.protocols.moves.CycleMover) → None

C++: protocols::moves::CycleMover::reset_cycle_index() –> void

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

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

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.MoverContainer, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.MoverContainer, pose: pyrosetta.rosetta.core.pose.Pose) → None

Sets the input Pose for both the container

and the contained movers, for rmsd

C++: protocols::moves::MoverContainer::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.MoverContainer, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::MoverContainer::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

size(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → int

C++: protocols::moves::MoverContainer::size() const –> unsigned long

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

weights(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.utility.vector0_double

C++: protocols::moves::MoverContainer::weights() const –> const class utility::vector0<double, class std::allocator<double> > &

class pyrosetta.rosetta.protocols.moves.CyclicMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

A simple class for cycling between movers in consecutive calls to apply()

apply(self: pyrosetta.rosetta.protocols.moves.CyclicMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::CyclicMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.CyclicMover, : pyrosetta.rosetta.protocols.moves.CyclicMover) → pyrosetta.rosetta.protocols.moves.CyclicMover

C++: protocols::moves::CyclicMover::operator=(const class protocols::moves::CyclicMover &) –> class protocols::moves::CyclicMover &

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

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

enqueue(self: pyrosetta.rosetta.protocols.moves.CyclicMover, mover: pyrosetta.rosetta.protocols.moves.Mover) → None

Enqueue the specified mover for execution

C++: protocols::moves::CyclicMover::enqueue(class std::shared_ptr<class protocols::moves::Mover>) –> void

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

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

C++: protocols::moves::CyclicMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

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

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

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

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.moves.DualMonteCarlo

Bases: pybind11_builtins.pybind11_object

DualMonteCarlo is a wrapper class around MonteCarlo. Its original purpose is to allow for Boltzmann scoring a pose in centroid mode while simultaneously tracking a fullatom equivalent. It should work for any paired poses. Generally, “DMC_pose” refers to the pose this class tracks, whereas “MC_pose” refers to the one used by the underlying MC object. While this class contains a MonteCarlo object (by composition, not inheritance); you cannot pass in a MC object to it, nor can you get an OP to that object. const access to the underlying MC is provided at this time; if you want nonconst access you can write it in but beware that the user can then ruin the bookkeeping! Also note that I (SML) left the framework in place in comments for a lot of MC’s functions within DMC like checkpointing and counters. Flesh these out if you want them…

MC(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo) → pyrosetta.rosetta.protocols.moves.MonteCarlo

const access to MC object

C++: protocols::moves::DualMonteCarlo::MC() const –> const class protocols::moves::MonteCarlo &

boltzmann(*args, **kwargs)

Overloaded function.

1. boltzmann(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo, DMC_pose: pyrosetta.rosetta.core.pose.Pose, MC_pose: pyrosetta.rosetta.core.pose.Pose) -> bool
2. boltzmann(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo, DMC_pose: pyrosetta.rosetta.core.pose.Pose, MC_pose: pyrosetta.rosetta.core.pose.Pose, move_type: str) -> bool

C++: protocols::moves::DualMonteCarlo::boltzmann(class core::pose::Pose &, class core::pose::Pose &, const class std::basic_string<char> &) –> bool

last_accepted_pose(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo) → pyrosetta.rosetta.core.pose.Pose

this gets you only the DMC’s pose; call MC directly for its. Note that this pose is accepted based on the partner pose in the underlying MC.

C++: protocols::moves::DualMonteCarlo::last_accepted_pose() const –> const class core::pose::Pose &

last_accepted_score(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo) → float

C++: protocols::moves::DualMonteCarlo::last_accepted_score() const –> double

lowest_score(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo) → float

C++: protocols::moves::DualMonteCarlo::lowest_score() const –> double

lowest_score_pose(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::DualMonteCarlo::lowest_score_pose() const –> const class core::pose::Pose &

recover_low(*args, **kwargs)

Overloaded function.

1. recover_low(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo, DMC_pose: pyrosetta.rosetta.core.pose.Pose) -> None

Copies the lowest_score_ pose into the input pose, as well as into

last_accepted_pose_. Copies action for underlying MC but does not return that pose.

C++: protocols::moves::DualMonteCarlo::recover_low(class core::pose::Pose &) –> void

2. recover_low(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo, DMC_pose: pyrosetta.rosetta.core.pose.Pose, MC_pose: pyrosetta.rosetta.core.pose.Pose) -> None

Copies the lowest_score_ pose into the input pose, as well as into

last_accepted_pose_. Always copies action for underlying MC. This version returns the MC’s pose.

C++: protocols::moves::DualMonteCarlo::recover_low(class core::pose::Pose &, class core::pose::Pose &) –> void

reset(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo, DMC_pose: pyrosetta.rosetta.core.pose.Pose, MC_pose: pyrosetta.rosetta.core.pose.Pose) → None

sets lowest and last_accepted poses to pose; calls MC’s reset too

C++: protocols::moves::DualMonteCarlo::reset(const class core::pose::Pose &, const class core::pose::Pose &) –> void

score_function(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::moves::DualMonteCarlo::score_function() const –> const class core::scoring::ScoreFunction &

show_scores(self: pyrosetta.rosetta.protocols.moves.DualMonteCarlo) → None

C++: protocols::moves::DualMonteCarlo::show_scores() const –> void

class pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

This Mover runs a Filter and dumps the report_sm value to Pose’s extra scores (for later JD reporting) To do the same for all filters, use WriteFiltersToPose.

apply(self: pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover, : pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover) → pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::operator=(const class protocols::moves::FilterReportAsPoseExtraScoresMover &) –> class protocols::moves::FilterReportAsPoseExtraScoresMover &

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

required in the context of the parser/scripting scheme

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

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

required in the context of the parser/scripting scheme

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::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_filter(self: pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::get_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

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.moves.FilterReportAsPoseExtraScoresMover) → str

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::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_report_as(self: pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover) → str

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::get_report_as() const –> const std::string &

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

mover_name() → str

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::mover_name() –> std::string

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

parse XML tag (to use this Mover in Rosetta Scripts)

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

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

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

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_filter(self: pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover, filter: pyrosetta.rosetta.protocols.filters.Filter) → None

set filter we report from

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::set_filter(class std::shared_ptr<class protocols::filters::Filter>) –> void

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_report_as(self: pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover, report_as: str) → None

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::set_report_as(const class std::basic_string<char> &) –> 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.FilterReportAsPoseExtraScoresMover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.FilterReportAsPoseExtraScoresMover, output: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::moves::FilterReportAsPoseExtraScoresMover::show(class std::basic_ostream<char> &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.moves.FilterReporterMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

A FilterMover that also calls report() on apply()

apply(self: pyrosetta.rosetta.protocols.moves.FilterReporterMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::FilterReporterMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.FilterReporterMover, rhs: pyrosetta.rosetta.protocols.moves.FilterReporterMover) → pyrosetta.rosetta.protocols.moves.FilterReporterMover

C++: protocols::moves::FilterReporterMover::operator=(const class protocols::moves::FilterReporterMover &) –> class protocols::moves::FilterReporterMover &

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

C++: protocols::moves::FilterReporterMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::FilterReporterMover::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_filter(self: pyrosetta.rosetta.protocols.moves.FilterReporterMover) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::moves::FilterReporterMover::get_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

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_mover(self: pyrosetta.rosetta.protocols.moves.FilterReporterMover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::FilterReporterMover::get_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

get_name(self: pyrosetta.rosetta.protocols.moves.FilterReporterMover) → str

C++: protocols::moves::FilterReporterMover::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_out(self: pyrosetta.rosetta.protocols.moves.FilterReporterMover) → pyrosetta.rosetta.std.ostream

C++: protocols::moves::FilterReporterMover::get_out() –> std::ostream &

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

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

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

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

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

set_filter(self: pyrosetta.rosetta.protocols.moves.FilterReporterMover, filter: pyrosetta.rosetta.protocols.filters.Filter) → None

C++: protocols::moves::FilterReporterMover::set_filter(const class std::shared_ptr<class protocols::filters::Filter> &) –> 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_mover(self: pyrosetta.rosetta.protocols.moves.FilterReporterMover, mover: pyrosetta.rosetta.protocols.moves.Mover) → None

C++: protocols::moves::FilterReporterMover::set_mover(const class std::shared_ptr<class protocols::moves::Mover> &) –> 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_out(self: pyrosetta.rosetta.protocols.moves.FilterReporterMover, out: pyrosetta.rosetta.std.ostream) → None

C++: protocols::moves::FilterReporterMover::set_out(const class std::basic_ostream<char> &) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.moves.GeometricFunc

Bases: pyrosetta.rosetta.protocols.moves.RampingFunc

Ramps rapidly from the starting value to the final value. Not 1 at x=1. Doesn’t really finish at (1,1). func(x) = 1 - exp( -1 * x * inv_xval_at_0p5 * 0.6931 );

assign(self: pyrosetta.rosetta.protocols.moves.GeometricFunc, : pyrosetta.rosetta.protocols.moves.GeometricFunc) → pyrosetta.rosetta.protocols.moves.GeometricFunc

C++: protocols::moves::GeometricFunc::operator=(const class protocols::moves::GeometricFunc &) –> class protocols::moves::GeometricFunc &

func(self: pyrosetta.rosetta.protocols.moves.GeometricFunc, x: float) → float

C++: protocols::moves::GeometricFunc::func(double) const –> double

class pyrosetta.rosetta.protocols.moves.InvGeometricFunc

Bases: pyrosetta.rosetta.protocols.moves.RampingFunc

Ramps slowly from the starting value to the final value Non-zero for x = 0. Doesn’t really start at (0,0). func(x) = exp( -1 * ( 1 - x ) / ( 1 - xval_at_0p5 ) * 0.6931 );

assign(self: pyrosetta.rosetta.protocols.moves.InvGeometricFunc, : pyrosetta.rosetta.protocols.moves.InvGeometricFunc) → pyrosetta.rosetta.protocols.moves.InvGeometricFunc

C++: protocols::moves::InvGeometricFunc::operator=(const class protocols::moves::InvGeometricFunc &) –> class protocols::moves::InvGeometricFunc &

func(self: pyrosetta.rosetta.protocols.moves.InvGeometricFunc, x: float) → float

C++: protocols::moves::InvGeometricFunc::func(double) const –> double

class pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

A mover that repeatedly applies a sub-mover (up to a given maximum) until the given filter returns values within a certain delta for a given number of cycles.

apply(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::IteratedConvergenceMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover, : pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover) → pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover

C++: protocols::moves::IteratedConvergenceMover::operator=(const class protocols::moves::IteratedConvergenceMover &) –> class protocols::moves::IteratedConvergenceMover &

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

required in the context of the parser/scripting scheme

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

cycles(*args, **kwargs)

Overloaded function.

1. cycles(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover, cycles: int) -> None

C++: protocols::moves::IteratedConvergenceMover::cycles(unsigned long) –> void

2. cycles(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover) -> int

C++: protocols::moves::IteratedConvergenceMover::cycles() const –> unsigned long

delta(*args, **kwargs)

Overloaded function.

1. delta(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover, delta: float) -> None

C++: protocols::moves::IteratedConvergenceMover::delta(double) –> void

2. delta(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover) -> float

C++: protocols::moves::IteratedConvergenceMover::delta() const –> double

filter(*args, **kwargs)

Overloaded function.

1. filter(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover, filter: pyrosetta.rosetta.protocols.filters.Filter) -> None

C++: protocols::moves::IteratedConvergenceMover::filter(class std::shared_ptr<const class protocols::filters::Filter>) –> void

2. filter(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover) -> pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::moves::IteratedConvergenceMover::filter() const –> class std::shared_ptr<const class protocols::filters::Filter>

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

required in the context of the parser/scripting scheme

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

C++: protocols::moves::IteratedConvergenceMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

maxcycles(*args, **kwargs)

Overloaded function.

1. maxcycles(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover, maxcycles: int) -> None

C++: protocols::moves::IteratedConvergenceMover::maxcycles(unsigned long) –> void

2. maxcycles(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover) -> int

C++: protocols::moves::IteratedConvergenceMover::maxcycles() const –> unsigned long

mover_name() → str

C++: protocols::moves::IteratedConvergenceMover::mover_name() –> std::string

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

parse XML (specifically in the context of the parser/scripting scheme)

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

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

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

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

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

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

submover(*args, **kwargs)

Overloaded function.

1. submover(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover, mover: pyrosetta.rosetta.protocols.moves.Mover) -> None

C++: protocols::moves::IteratedConvergenceMover::submover(class std::shared_ptr<class protocols::moves::Mover>) –> void

2. submover(self: pyrosetta.rosetta.protocols.moves.IteratedConvergenceMover) -> pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::IteratedConvergenceMover::submover() const –> class std::shared_ptr<class protocols::moves::Mover>

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.moves.MCA

Bases: pybind11_builtins.pybind11_object

Members:

MCA_accepted_score_beat_low

MCA_accepted_score_beat_last

MCA_accepted_thermally

MCA_rejected

class pyrosetta.rosetta.protocols.moves.MonteCarlo

Bases: pybind11_builtins.pybind11_object

This object is responsible for all of the major functions needed in a Monte Carlo simulation. Its main purpose is to apply the Metropolis Criterion on a pose, based on a ScoreFunction, temperature, and the previously accepted pose. It stores the lowest-energy pose ecountered, the last-accepted pose in the simulation, and various other statistics.

Output Methods:

MonteCarlo.show_counters() MonteCarlo.show_scores() MonteCarlo.show_state()

Common Methods:

MonteCarlo.last_accepted_score MonteCarlo.last_accepted_pose MonteCarlo.lowest_score MonteCarlo.lowest_score_pose MonteCarlo.score_function MonteCarlo.set_temperature MonteCarlo.temperature

boltzmann(*args, **kwargs)

Overloaded function.

1. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose) -> bool
2. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose, move_type: str) -> bool
3. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose, move_type: str, proposal_density_ratio: float) -> bool
4. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose, move_type: str, proposal_density_ratio: float, inner_score_delta_over_temperature: float) -> bool

Applies the Metropolis Criterion on pose based on

the ScoreFunction, temperature, and the last accepted pose. This method evaluates the change in score, compares the trial pose to the last accepted pose, and updates the pose structure and simulation statistics appropriately

example(s):

mc.boltzmann( pose )

See also:

MonteCarlo MonteCarlo.last_accepted_score MonteCarlo.lowest_score

C++: protocols::moves::MonteCarlo::boltzmann(class core::pose::Pose &, const class std::basic_string<char> &, const double, const double) –> bool

5. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float) -> bool
6. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float, move_type: str) -> bool
7. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float, move_type: str, proposal_density_ratio: float) -> bool
8. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float, move_type: str, proposal_density_ratio: float, inner_score_delta_over_temperature: float) -> bool
9. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float, move_type: str, proposal_density_ratio: float, inner_score_delta_over_temperature: float, check_lowest_score: bool) -> bool

Applies the Metropolis Criterion on the inputted

pose based on the supplied score delta

example(s):

See also:

MonteCarlo

C++: protocols::moves::MonteCarlo::boltzmann(double, const class std::basic_string<char> &, const double, const double, bool) –> bool

10. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float, pose: pyrosetta.rosetta.core.pose.Pose) -> bool
11. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float, pose: pyrosetta.rosetta.core.pose.Pose, move_type: str) -> bool
12. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float, pose: pyrosetta.rosetta.core.pose.Pose, move_type: str, proposal_density_ratio: float) -> bool
13. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float, pose: pyrosetta.rosetta.core.pose.Pose, move_type: str, proposal_density_ratio: float, inner_score_delta_over_temperature: float) -> bool
14. boltzmann(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float, pose: pyrosetta.rosetta.core.pose.Pose, move_type: str, proposal_density_ratio: float, inner_score_delta_over_temperature: float, check_lowest_score: bool) -> bool

Applies the Metropolis Criterion on the inputted

pose based on the supplied score delta. Updates the Pose Structure accordingly.

example(s):

See also:

MonteCarlo

C++: protocols::moves::MonteCarlo::boltzmann(double, class core::pose::Pose &, const class std::basic_string<char> &, const double, const double, bool) –> bool

change_weight(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, t: pyrosetta.rosetta.core.scoring.ScoreType, setting: float) → None

Change the weight on a score term in the object’s scorefunction. Useful when we don’t want to reset the whole scorefunction during an annealing step.

C++: protocols::moves::MonteCarlo::change_weight(const enum core::scoring::ScoreType &, const double &) –> void

check_frequency(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → int

C++: protocols::moves::MonteCarlo::check_frequency() const –> unsigned long

clear_poses(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Removes last accepted pose and lowest score pose

example(s):

mc.clear_poses()

See also:

MonteCarlo MonteCarlo.last_accepted_pose MonteCarlo.lowest_score_pose MonteCarlo.recover_low MonteCarlo.reset MonteCarlo.set_last_accepted_pose MonteCarlo.set_lowest_score_pose

C++: protocols::moves::MonteCarlo::clear_poses() –> void

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

C++: protocols::moves::MonteCarlo::clone() –> class std::shared_ptr<class protocols::moves::MonteCarlo>

eval_lowest_score_pose(*args, **kwargs)

Overloaded function.

1. eval_lowest_score_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose) -> bool
2. eval_lowest_score_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose, score_pose: bool) -> bool
3. eval_lowest_score_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose, score_pose: bool, update_stats: bool) -> bool
4. eval_lowest_score_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose, score_pose: bool, update_stats: bool, move_type: str) -> bool

Compares score of <pose> to the lowest score found.

If lower, sets the current lowest score pose and lowest score. Use internal pose energies if score_pose is false. Used to evaluate lowest score without boltzmann. Does not change pose structure.

Does not update simulation statistics or last accepts by default.

example(s):

mc.eval_lowest_score_pose( pose )

See also:

MonteCarlo MonteCarlo.lowest_score MonteCarlo.lowest_score_pose MonteCarlo.recover_low

C++: protocols::moves::MonteCarlo::eval_lowest_score_pose(class core::pose::Pose &, bool, bool, const class std::basic_string<char> &) –> bool

get_update_boinc(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → bool

C++: protocols::moves::MonteCarlo::get_update_boinc() const –> bool

heat_after_cycles(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → int

no brief for now

C++: protocols::moves::MonteCarlo::heat_after_cycles() const –> unsigned long

last_accept(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → int

Returns the number of trials since last acceptance

example(s):

mc.last_accept()

See also:

MonteCarlo MonteCarlo.show_counters MonteCarlo.last_accepted_pose MonteCarlo.last_accepted_score

C++: protocols::moves::MonteCarlo::last_accept() const –> unsigned long

last_accepted_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → pyrosetta.rosetta.core.pose.Pose

Returns the last accepted pose

example(s):

mc.last_accepted_pose()

See also:

MonteCarlo MonteCarlo.last_accept MonteCarlo.last_accepted_score

C++: protocols::moves::MonteCarlo::last_accepted_pose() const –> const class core::pose::Pose &

last_accepted_score(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → float

Returns the score value of the last accepted pose

example(s):

mc.last_accepted_score()

See also:

MonteCarlo MonteCarlo.last_accept MonteCarlo.last_accepted_pose MonteCarlo.show_counters MonteCarlo.show_scores MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::last_accepted_score() const –> double

last_score(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → float

Returns the score value of the last score

example(s):

mc.last_accepted_score()

See also:

MonteCarlo MonteCarlo.last_accept MonteCarlo.last_accepted_pose MonteCarlo.show_counters MonteCarlo.show_scores MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::last_score() const –> double

lowest_score(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → float

Returns the score value of the lowest score pose encountered

example(s):

mc.lowest_score()

See also:

MonteCarlo MonteCarlo.lowest_score_pose MonteCarlo.show_counters MonteCarlo.show_scores MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::lowest_score() const –> double

lowest_score_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → pyrosetta.rosetta.core.pose.Pose

Returns the lowest score pose encountered

example(s):

mc.lowest_score_pose()

See also:

MonteCarlo MonteCarlo.last_accepted_pose MonteCarlo.lowest_score

C++: protocols::moves::MonteCarlo::lowest_score_pose() const –> const class core::pose::Pose &

mc_accepted(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → pyrosetta.rosetta.protocols.moves.MCA

Returns mc_accepted, informative of the last move applied

Note: Returns true for an accept, false otherwise

3 = accepted:score beat low score and last_accepted score 2 = accepted:score beat last_accepted score 1 = thermally accepted: score worse than last_accepted score 0 = not accepted

example(s):

mc.mc_accepted()

See also:

MonteCarlo MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::mc_accepted() const –> enum protocols::moves::MCA

mc_accepted_string(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → str

Returns mc_accepted as a human-readable string, informative of the last move applied

C++: protocols::moves::MonteCarlo::mc_accepted_string() const –> std::string

push_back(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, : protocols::moves::MonteCarloExceptionConverge) → None

no brief for now

C++: protocols::moves::MonteCarlo::push_back(class std::shared_ptr<class protocols::moves::MonteCarloExceptionConverge>) –> void

recover_low(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose) → None

Sets the input <pose> and last accepted pose to

the lowest score pose

example(s):

mc.recover_low( pose )

See also:

MonteCarlo MonteCarlo.last_accept MonteCarlo.last_accepted_pose MonteCarlo.last_accepted_score MonteCarlo.lowest_score MonteCarlo.lowest_score_pose

C++: protocols::moves::MonteCarlo::recover_low(class core::pose::Pose &) –> void

reset(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose) → None

Sets lowest score pose and last accepted pose to

the score of <pose>

(does not reset counters)

example(s):

mc.reset(pose)

See also:

MonteCarlo MonteCarlo.last_accepted_pose MonteCarlo.last_accepted_score MonteCarlo.lowest_score MonteCarlo.lowest_scored_pose

C++: protocols::moves::MonteCarlo::reset(const class core::pose::Pose &) –> void

reset_counters(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Resets the mover counters

example(s):

mc.reset_counters()

See alse:

MonteCarlo MonteCarlo.show_counters

C++: protocols::moves::MonteCarlo::reset_counters() –> void

reset_scorefxn(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, init_pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Resets the ScoreFunction

C++: protocols::moves::MonteCarlo::reset_scorefxn(const class core::pose::Pose &, const class core::scoring::ScoreFunction &) –> void

score_function(*args, **kwargs)

Overloaded function.

1. score_function(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

Sets the ScoreFunction to <scorefxn> , re-scores

last accepted pose and lowest score pose

example(s):

mc.score_function( scorefxn )

See also:

MonteCarlo MonteCarlo.boltzmann MonteCarlo.set_temperature MonteCarlo.temperature ScoreFunction create_score_function

C++: protocols::moves::MonteCarlo::score_function(const class core::scoring::ScoreFunction &) –> void

2. score_function(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Returns the MonteCarlo ScoreFunction

example(s):

mc.score_function() mc.score_function()( pose )

See also:

MonteCarlo MonteCarlo.boltzmann MonteCarlo.set_temperature MonteCarlo.temperature ScoreFunction create_score_function

C++: protocols::moves::MonteCarlo::score_function() const –> const class core::scoring::ScoreFunction &

set_autotemp(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, setting: bool, quench_temp: float) → None

Sets autotemp to quench_temp

example(s): See also:

MonteCarlo MonteCarlo.autotemp MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::set_autotemp(const bool, const double) –> void

set_heat_after_cycles(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, setting: int) → None

no brief for now

C++: protocols::moves::MonteCarlo::set_heat_after_cycles(unsigned long) –> void

set_last_accepted(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float) → None

C++: protocols::moves::MonteCarlo::set_last_accepted(double) –> void

set_last_accepted_pose(*args, **kwargs)

Overloaded function.

1. set_last_accepted_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Sets the last accepted pose to the score of <pose>

(does not reset counters)

C++: protocols::moves::MonteCarlo::set_last_accepted_pose(const class core::pose::Pose &) –> void

2. set_last_accepted_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose, score: float) -> None

Sets the last accepted pose and last accepted score

(does not reset counters)

C++: protocols::moves::MonteCarlo::set_last_accepted_pose(const class core::pose::Pose &, double) –> void

set_last_score(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float) → None

Set the last score.

C++: protocols::moves::MonteCarlo::set_last_score(double) –> void

set_lowest(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float) → None

C++: protocols::moves::MonteCarlo::set_lowest(double) –> void

set_lowest_score_pose(*args, **kwargs)

Overloaded function.

1. set_lowest_score_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::moves::MonteCarlo::set_lowest_score_pose(const class core::pose::Pose &) –> void

2. set_lowest_score_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, pose: pyrosetta.rosetta.core.pose.Pose, score: float) -> None

C++: protocols::moves::MonteCarlo::set_lowest_score_pose(const class core::pose::Pose &, double) –> void

set_temperature(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, temp: float) → None

Sets the temperature value used in the Metropolis Criterion to <temp>

example(s):

mc.set_temperature( temp )

See also:

MonteCarlo MonteCarlo.temperature MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::set_temperature(const double) –> void

set_total_score_last_considered(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, score: float) → None

C++: protocols::moves::MonteCarlo::set_total_score_last_considered(double) –> void

set_update_boinc(self: pyrosetta.rosetta.protocols.moves.MonteCarlo, setting: bool) → None

no brief for now

C++: protocols::moves::MonteCarlo::set_update_boinc(bool) –> void

show_counters(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Displays the number of trials performed, fraction

of trial moves accepted, and the average energy drop per accepted trial by mover types applied (unknown movers or perturbations are listed as “unktrials”)

example(s):

mc.show_counters()

Output as:

protocols.moves.MonteCarlo: unk trials= X; accepts= Y; energy_drop/trial= Z

See also:

MonteCarlo MonteCarlo.show_scores MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::show_counters() const –> void

show_scores(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Displays the last accepted score and the lowest score

example(s):

mc.show_scores()

Output as:

protocols.moves.MonteCarlo: MonteCarlo:: last_accepted_score,lowest_score: X Y

See also:

MonteCarlo MonteCarlo.last_accepted_score MonteCarlo.lowest_score MonteCarlo.show_counters MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::show_scores() const –> void

show_state(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Displays the entire MonteCarlo state

temperature, scores, annealing settings, move statistics, move counters (show_counters)

example(s):

mc.show_state()

Output as:

protocols.moves.MonteCarlo: MC: t l1 l2 las lws la au qu mca

t= temperature l1= (*score_function_)(*last_accepted_pose_) l2= (*score_function_)(*lowest_score_pose_) las= last accepted score lws= lowest score la= last_accept_ au= autotemp_ qu= quench_temp_ mca= mc_accepted_

See also:

MonteCarlo MonteCarlo.show_counters MonteCarlo.show_scores MonteCarlo.last_accepted_score MonteCarlo.lowest_score MonteCarlo.temperature

C++: protocols::moves::MonteCarlo::show_state() const –> void

temperature(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → float

Returns the temperature value used in the Metropolis Criterion

example(s):

mc.temperature()

See also:

MonteCarlo MonteCarlo.set_temperature MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::temperature() const –> double

total_score_of_last_considered_pose(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → float

C++: protocols::moves::MonteCarlo::total_score_of_last_considered_pose() const –> double

total_trials(self: pyrosetta.rosetta.protocols.moves.MonteCarlo) → int

Returns the total number of trials since the last reset

: MonteCarlo.boltzmann(pose) updates the number of trials

example(s):

mc.total_trials()

See also:

MonteCarlo MonteCarlo.last_accept MonteCarlo.show_counters MonteCarlo.show_state

C++: protocols::moves::MonteCarlo::total_trials() const –> unsigned long

class pyrosetta.rosetta.protocols.moves.MonteCarloUtil

Bases: pyrosetta.rosetta.protocols.moves.Mover

the MCResetMover applies a monte carlo reset

apply(self: pyrosetta.rosetta.protocols.moves.MonteCarloUtil, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::MonteCarloUtil::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.MonteCarloUtil, : pyrosetta.rosetta.protocols.moves.MonteCarloUtil) → pyrosetta.rosetta.protocols.moves.MonteCarloUtil

C++: protocols::moves::MonteCarloUtil::operator=(const class protocols::moves::MonteCarloUtil &) –> class protocols::moves::MonteCarloUtil &

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

C++: protocols::moves::MonteCarloUtil::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

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

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

C++: protocols::moves::MonteCarloUtil::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.MonteCarloUtil, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

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

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

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

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.moves.MoverCreator

Bases: pybind11_builtins.pybind11_object

Abstract base class for a Mover factory; the Creator class is responsible for creating a particular mover class.

assign(self: pyrosetta.rosetta.protocols.moves.MoverCreator, : pyrosetta.rosetta.protocols.moves.MoverCreator) → pyrosetta.rosetta.protocols.moves.MoverCreator

C++: protocols::moves::MoverCreator::operator=(const class protocols::moves::MoverCreator &) –> class protocols::moves::MoverCreator &

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

Return a new mover.

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

keyname(self: pyrosetta.rosetta.protocols.moves.MoverCreator) → str

Return the tag name associated with this factory.

C++: protocols::moves::MoverCreator::keyname() const –> std::string

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

Describe the schema for the Mover that this Creator is responsible for

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

class pyrosetta.rosetta.protocols.moves.MoverStatus

Bases: pybind11_builtins.pybind11_object

return status for movers - mover was successful, failed but can be retried, etc; used mostly by job dist.

Documention for individual codes from SML, and reflects the original intent behind them (more than current usage)

Members:

MS_SUCCESS

FAIL_RETRY

FAIL_DO_NOT_RETRY

FAIL_BAD_INPUT

FAIL

MS_FAIL_RETRY

MS_FAIL_DO_NOT_RETRY

MS_FAIL_BAD_INPUT

MS_FAIL

class pyrosetta.rosetta.protocols.moves.RandomMover

Bases: pyrosetta.rosetta.protocols.moves.MoverContainer

RandomMover picks a random move and applies it

If nmoves is greater than 1, it repeats this process nmoves times for each call to apply(). This mover supports weights — the individual moves are sampled with frequency proportional to their weight given with add_mover( mover, weight );

add_mover(*args, **kwargs)

Overloaded function.

1. add_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, mover_in: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. add_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, mover_in: pyrosetta.rosetta.protocols.moves.Mover, weight_in: float) -> None

Adds a mover to the end of this container

C++: protocols::moves::MoverContainer::add_mover(class std::shared_ptr<class protocols::moves::Mover>, double) –> void

apply(self: pyrosetta.rosetta.protocols.moves.RandomMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::RandomMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.RandomMover, : pyrosetta.rosetta.protocols.moves.RandomMover) → pyrosetta.rosetta.protocols.moves.RandomMover

C++: protocols::moves::RandomMover::operator=(const class protocols::moves::RandomMover &) –> class protocols::moves::RandomMover &

clear(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → None

C++: protocols::moves::MoverContainer::clear() –> void

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

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

C++: protocols::moves::RandomMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

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

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

front(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::MoverContainer::front() –> 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_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, index: int) → str

C++: protocols::moves::MoverContainer::get_mover(unsigned long) const –> std::string

get_name(self: pyrosetta.rosetta.protocols.moves.RandomMover) → str

C++: protocols::moves::RandomMover::get_name() const –> std::string

get_name_individual_mover(self: pyrosetta.rosetta.protocols.moves.RandomMover, index: int) → str

C++: protocols::moves::RandomMover::get_name_individual_mover(unsigned long) –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

mover_name() → str

C++: protocols::moves::RandomMover::mover_name() –> std::string

movers(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.utility.vector0_std_shared_ptr_protocols_moves_Mover_t

C++: protocols::moves::MoverContainer::movers() const –> const class utility::vector0<class std::shared_ptr<class protocols::moves::Mover>, class std::allocator<class std::shared_ptr<class protocols::moves::Mover> > > &

name() → str

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

nr_moves(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → int

C++: protocols::moves::MoverContainer::nr_moves() –> unsigned long

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.RandomMover, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

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

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

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

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.MoverContainer, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.MoverContainer, pose: pyrosetta.rosetta.core.pose.Pose) → None

Sets the input Pose for both the container

and the contained movers, for rmsd

C++: protocols::moves::MoverContainer::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.MoverContainer, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::MoverContainer::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

size(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → int

C++: protocols::moves::MoverContainer::size() const –> unsigned long

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

weights(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.utility.vector0_double

C++: protocols::moves::MoverContainer::weights() const –> const class utility::vector0<double, class std::allocator<double> > &

class pyrosetta.rosetta.protocols.moves.RepeatMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

A Mover that repeats an input Mover a user-specified number of times

Common Methods:

RepeatMover.apply

apply(self: pyrosetta.rosetta.protocols.moves.RepeatMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Repeats the input Mover a specified number of times

C++: protocols::moves::RepeatMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.RepeatMover, : pyrosetta.rosetta.protocols.moves.RepeatMover) → pyrosetta.rosetta.protocols.moves.RepeatMover

C++: protocols::moves::RepeatMover::operator=(const class protocols::moves::RepeatMover &) –> class protocols::moves::RepeatMover &

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

C++: protocols::moves::RepeatMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::RepeatMover::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_mover(self: pyrosetta.rosetta.protocols.moves.RepeatMover) → str

C++: protocols::moves::RepeatMover::get_mover() const –> std::string

get_name(self: pyrosetta.rosetta.protocols.moves.RepeatMover) → str

C++: protocols::moves::RepeatMover::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_nmoves(self: pyrosetta.rosetta.protocols.moves.RepeatMover) → int

C++: protocols::moves::RepeatMover::get_nmoves() const –> unsigned long

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

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

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

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

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.moves.ResId

Bases: pybind11_builtins.pybind11_object

/ Override the get and set methods in containers of ResId objects (see CompoundStatementFilter and DockDesignMover for examples)

assign(self: pyrosetta.rosetta.protocols.moves.ResId, : pyrosetta.rosetta.protocols.moves.ResId) → pyrosetta.rosetta.protocols.moves.ResId

C++: protocols::moves::ResId::operator=(const class protocols::moves::ResId &) –> class protocols::moves::ResId &

get_resid(self: pyrosetta.rosetta.protocols.moves.ResId) → int

C++: protocols::moves::ResId::get_resid() –> unsigned long &

modifiable(*args, **kwargs)

Overloaded function.

1. modifiable(self: pyrosetta.rosetta.protocols.moves.ResId) -> bool

should another method be able to modify resid_. This is used by modify_ResId_based_object as a test

C++: protocols::moves::ResId::modifiable() const –> bool

2. modifiable(self: pyrosetta.rosetta.protocols.moves.ResId, u: bool) -> None

C++: protocols::moves::ResId::modifiable(const bool) –> void

set_resid(self: pyrosetta.rosetta.protocols.moves.ResId, r: int) → None

C++: protocols::moves::ResId::set_resid(const unsigned long) –> void

class pyrosetta.rosetta.protocols.moves.SequenceMover

Bases: pyrosetta.rosetta.protocols.moves.MoverContainer

A Mover that iterates through a vector of Movers, applying each one sequentially

Common Methods:

SequenceMover.add_mover SequenceMover.apply

add_mover(*args, **kwargs)

Overloaded function.

1. add_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, mover_in: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. add_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, mover_in: pyrosetta.rosetta.protocols.moves.Mover, weight_in: float) -> None

Adds a mover to the end of this container

C++: protocols::moves::MoverContainer::add_mover(class std::shared_ptr<class protocols::moves::Mover>, double) –> void

apply(self: pyrosetta.rosetta.protocols.moves.SequenceMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Applies a series of movers sequentially on a Pose

example(s):

seqmover.apply(pose)

See also:

MinMover RepeatMover SequenceMover TrialMover

C++: protocols::moves::SequenceMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.SequenceMover, : pyrosetta.rosetta.protocols.moves.SequenceMover) → pyrosetta.rosetta.protocols.moves.SequenceMover

C++: protocols::moves::SequenceMover::operator=(const class protocols::moves::SequenceMover &) –> class protocols::moves::SequenceMover &

clear(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → None

C++: protocols::moves::MoverContainer::clear() –> void

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

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

deep copy of all contained movers.

C++: protocols::moves::SequenceMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

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

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

front(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::MoverContainer::front() –> 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_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, index: int) → str

C++: protocols::moves::MoverContainer::get_mover(unsigned long) const –> std::string

get_name(self: pyrosetta.rosetta.protocols.moves.SequenceMover) → str

C++: protocols::moves::SequenceMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

movers(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.utility.vector0_std_shared_ptr_protocols_moves_Mover_t

C++: protocols::moves::MoverContainer::movers() const –> const class utility::vector0<class std::shared_ptr<class protocols::moves::Mover>, class std::allocator<class std::shared_ptr<class protocols::moves::Mover> > > &

name() → str

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

nr_moves(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → int

C++: protocols::moves::MoverContainer::nr_moves() –> unsigned long

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

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

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

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

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.MoverContainer, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.MoverContainer, pose: pyrosetta.rosetta.core.pose.Pose) → None

Sets the input Pose for both the container

and the contained movers, for rmsd

C++: protocols::moves::MoverContainer::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.MoverContainer, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::MoverContainer::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

size(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → int

C++: protocols::moves::MoverContainer::size() const –> unsigned long

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

use_mover_status(*args, **kwargs)

Overloaded function.

1. use_mover_status(self: pyrosetta.rosetta.protocols.moves.SequenceMover, flag: bool) -> None

MoverStatus of the mover will be evaluated after each mover

C++: protocols::moves::SequenceMover::use_mover_status(const bool) –> void

2. use_mover_status(self: pyrosetta.rosetta.protocols.moves.SequenceMover) -> bool

C++: protocols::moves::SequenceMover::use_mover_status() –> bool

weights(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.utility.vector0_double

C++: protocols::moves::MoverContainer::weights() const –> const class utility::vector0<double, class std::allocator<double> > &

class pyrosetta.rosetta.protocols.moves.StatsType

Bases: pybind11_builtins.pybind11_object

A TrialMover applies a Mover and then accepts or rejects the move according to a MonteCarlo object.

:

Each derived class should define its own apply() statement the apply (mc) which requires a monte carlo object and only keeps the move if the monte carlo test allows it

Monica Berrondo

Members:

all_stats

accept_reject

no_stats

class pyrosetta.rosetta.protocols.moves.SwitchMover

Bases: pyrosetta.rosetta.protocols.moves.MoverContainer

SwitchMover can hold multiple movers and execute only the requested one

In terms of RosettaScripts, it allows to have a single script with N- different behaviours that can be called through the parser:script_vars (for example). And it will log in the scores which mover was used.

add_mover(*args, **kwargs)

Overloaded function.

1. add_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, mover_in: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. add_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, mover_in: pyrosetta.rosetta.protocols.moves.Mover, weight_in: float) -> None

Adds a mover to the end of this container

C++: protocols::moves::MoverContainer::add_mover(class std::shared_ptr<class protocols::moves::Mover>, double) –> void

apply(self: pyrosetta.rosetta.protocols.moves.SwitchMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::SwitchMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.SwitchMover, : pyrosetta.rosetta.protocols.moves.SwitchMover) → pyrosetta.rosetta.protocols.moves.SwitchMover

C++: protocols::moves::SwitchMover::operator=(const class protocols::moves::SwitchMover &) –> class protocols::moves::SwitchMover &

clear(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → None

C++: protocols::moves::MoverContainer::clear() –> void

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

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

C++: protocols::moves::SwitchMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

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

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

front(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::MoverContainer::front() –> 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_mover(self: pyrosetta.rosetta.protocols.moves.MoverContainer, index: int) → str

C++: protocols::moves::MoverContainer::get_mover(unsigned long) const –> std::string

get_name(self: pyrosetta.rosetta.protocols.moves.SwitchMover) → str

C++: protocols::moves::SwitchMover::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_selected_mover(self: pyrosetta.rosetta.protocols.moves.SwitchMover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::SwitchMover::get_selected_mover() –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

mover_name() → str

C++: protocols::moves::SwitchMover::mover_name() –> std::string

movers(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.utility.vector0_std_shared_ptr_protocols_moves_Mover_t

C++: protocols::moves::MoverContainer::movers() const –> const class utility::vector0<class std::shared_ptr<class protocols::moves::Mover>, class std::allocator<class std::shared_ptr<class protocols::moves::Mover> > > &

name() → str

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

nr_moves(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → int

C++: protocols::moves::MoverContainer::nr_moves() –> unsigned long

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.SwitchMover, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

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

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

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

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

selected(*args, **kwargs)

Overloaded function.

1. selected(self: pyrosetta.rosetta.protocols.moves.SwitchMover) -> str

C++: protocols::moves::SwitchMover::selected() const –> std::string

2. selected(self: pyrosetta.rosetta.protocols.moves.SwitchMover, sele: str) -> None

C++: protocols::moves::SwitchMover::selected(class std::basic_string<char>) –> 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.MoverContainer, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.MoverContainer, pose: pyrosetta.rosetta.core.pose.Pose) → None

Sets the input Pose for both the container

and the contained movers, for rmsd

C++: protocols::moves::MoverContainer::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.MoverContainer, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::MoverContainer::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

size(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → int

C++: protocols::moves::MoverContainer::size() const –> unsigned long

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

weights(self: pyrosetta.rosetta.protocols.moves.MoverContainer) → pyrosetta.rosetta.utility.vector0_double

C++: protocols::moves::MoverContainer::weights() const –> const class utility::vector0<double, class std::allocator<double> > &

class pyrosetta.rosetta.protocols.moves.TrialMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

A TrialMover applies a Mover and then accepts or rejects the move according to a MonteCarlo object.

Common Methods:

TrialMover.apply TrialMover.set_mc

acceptance_rate(self: pyrosetta.rosetta.protocols.moves.TrialMover) → float

C++: protocols::moves::TrialMover::acceptance_rate() const –> double

apply(self: pyrosetta.rosetta.protocols.moves.TrialMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

Performs a single trial, apply the Mover and accept or

reject the move based on the MonteCarlo acceptance criteria

example(s):

trialmover.apply(pose)

See Also:

Pose MonteCarlo MonteCarlo.boltzmann RepeatMover SequenceMover TrialMover

C++: protocols::moves::TrialMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.TrialMover, : pyrosetta.rosetta.protocols.moves.TrialMover) → pyrosetta.rosetta.protocols.moves.TrialMover

C++: protocols::moves::TrialMover::operator=(const class protocols::moves::TrialMover &) –> class protocols::moves::TrialMover &

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

C++: protocols::moves::TrialMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

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

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

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

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

C++: protocols::moves::TrialMover::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_weights(self: pyrosetta.rosetta.protocols.moves.TrialMover, start_weight: float, end_weight: float, score_type: pyrosetta.rosetta.core.scoring.ScoreType, ramp_cycles: int) → None

C++: protocols::moves::TrialMover::initialize_weights(const double, const double, enum core::scoring::ScoreType, const int) –> void

keep_stats_type(*args, **kwargs)

Overloaded function.

1. keep_stats_type(self: pyrosetta.rosetta.protocols.moves.TrialMover) -> pyrosetta.rosetta.protocols.moves.StatsType

C++: protocols::moves::TrialMover::keep_stats_type() const –> enum protocols::moves::StatsType

2. keep_stats_type(self: pyrosetta.rosetta.protocols.moves.TrialMover, setting: pyrosetta.rosetta.protocols.moves.StatsType) -> None

C++: protocols::moves::TrialMover::keep_stats_type(enum protocols::moves::StatsType) –> void

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

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

mc(self: pyrosetta.rosetta.protocols.moves.TrialMover) → pyrosetta.rosetta.protocols.moves.MonteCarlo

Returns the underlying MonteCarlo object

C++: protocols::moves::TrialMover::mc() const –> const class protocols::moves::MonteCarlo &

mover(self: pyrosetta.rosetta.protocols.moves.TrialMover) → pyrosetta.rosetta.protocols.moves.Mover

Returns the underlying Mover

C++: protocols::moves::TrialMover::mover() const –> class std::shared_ptr<class protocols::moves::Mover>

name() → str

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

num_accepts(self: pyrosetta.rosetta.protocols.moves.TrialMover) → int

Returns the number of moves accepted by this TrialMover

C++: protocols::moves::TrialMover::num_accepts() const –> int

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.TrialMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

Requires that a MonteCarlo object has already been

loaded into the basic::datacache::DataMap in a prior MONTECARLOS objects section.

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

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

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

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.TrialMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::TrialMover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_mc(self: pyrosetta.rosetta.protocols.moves.TrialMover, mc_in: pyrosetta.rosetta.protocols.moves.MonteCarlo) → None

Sets the MonteCarlo object to <mc_in>

example(s):

trialmover.set_mc(mc)

See Also:

MonteCarlo MonteCarlo.boltzmann TrialMover

C++: protocols::moves::TrialMover::set_mc(class std::shared_ptr<class protocols::moves::MonteCarlo>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.TrialMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::TrialMover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.moves.UDPSocketClient

Bases: pybind11_builtins.pybind11_object

PyMOLMover helper class. Handle low level UDP transactions stuff. This is a port of original Python version of UDP socket client written writen for PyRosetta

assign(self: pyrosetta.rosetta.protocols.moves.UDPSocketClient, : pyrosetta.rosetta.protocols.moves.UDPSocketClient) → pyrosetta.rosetta.protocols.moves.UDPSocketClient

C++: protocols::moves::UDPSocketClient::operator=(const class protocols::moves::UDPSocketClient &) –> class protocols::moves::UDPSocketClient &

sendMessage(self: pyrosetta.rosetta.protocols.moves.UDPSocketClient, msg: str) → None

C++: protocols::moves::UDPSocketClient::sendMessage(class std::basic_string<char>) –> void

show(self: pyrosetta.rosetta.protocols.moves.UDPSocketClient, output: pyrosetta.rosetta.std.ostream) → None

C++: protocols::moves::UDPSocketClient::show(class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.protocols.moves.VectorPoseMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

A simple class used for a mover that acts on a vector of poses

apply(self: pyrosetta.rosetta.protocols.moves.VectorPoseMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::moves::VectorPoseMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.VectorPoseMover, : pyrosetta.rosetta.protocols.moves.VectorPoseMover) → pyrosetta.rosetta.protocols.moves.VectorPoseMover

C++: protocols::moves::VectorPoseMover::operator=(const class protocols::moves::VectorPoseMover &) –> class protocols::moves::VectorPoseMover &

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>

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.moves.VectorPoseMover) → str

C++: protocols::moves::VectorPoseMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

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

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

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

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

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

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

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

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

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

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

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

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

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

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_poses(self: pyrosetta.rosetta.protocols.moves.VectorPoseMover, poses: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t) → None

Set the vector of poses for the mover to act upon

C++: protocols::moves::VectorPoseMover::set_poses(const class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > > &) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

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

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

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

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

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

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

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

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

class pyrosetta.rosetta.protocols.moves.X11Colors

Bases: pybind11_builtins.pybind11_object

Members:

XC_first_color

XC_black

XC_AntiqueWhite

XC_BlanchedAlmond

XC_BlueViolet

XC_CadetBlue

XC_CornflowerBlue

XC_DarkBlue

XC_DarkCyan

XC_DarkGoldenrod

XC_DarkGray

XC_DarkGreen

XC_DarkGrey

XC_DarkKhaki

XC_DarkMagenta

XC_DarkOliveGreen

XC_DarkOrange

XC_DarkOrchid

XC_DarkRed

XC_DarkSalmon

XC_DarkSeaGreen

XC_DarkSlateBlue

XC_DarkSlateGray

XC_DarkSlateGrey

XC_DarkTurquoise

XC_DarkViolet

XC_DebianRed

XC_DeepPink

XC_DeepSkyBlue

XC_DimGray

XC_DimGrey

XC_DodgerBlue

XC_FloralWhite

XC_ForestGreen

XC_GhostWhite

XC_GreenYellow

XC_HotPink

XC_IndianRed

XC_LavenderBlush

XC_LawnGreen

XC_LemonChiffon

XC_LightBlue

XC_LightCoral

XC_LightCyan

XC_LightGoldenrod

XC_LightGoldenrodYellow

XC_LightGray

XC_LightGreen

XC_LightGrey

XC_LightPink

XC_LightSalmon

XC_LightSeaGreen

XC_LightSkyBlue

XC_LightSlateBlue

XC_LightSlateGray

XC_LightSlateGrey

XC_LightSteelBlue

XC_LightYellow

XC_LimeGreen

XC_MediumAquamarine

XC_MediumBlue

XC_MediumOrchid

XC_MediumPurple

XC_MediumSeaGreen

XC_MediumSlateBlue

XC_MediumSpringGreen

XC_MediumTurquoise

XC_MediumVioletRed

XC_MidnightBlue

XC_MintCream

XC_MistyRose

XC_NavajoWhite

XC_NavyBlue

XC_OldLace

XC_OliveDrab

XC_OrangeRed

XC_PaleGoldenrod

XC_PaleGreen

XC_PaleTurquoise

XC_PaleVioletRed

XC_PapayaWhip

XC_PeachPuff

XC_PowderBlue

XC_RosyBrown

XC_RoyalBlue

XC_SaddleBrown

XC_SandyBrown

XC_SeaGreen

XC_SkyBlue

XC_SlateBlue

XC_SlateGray

XC_SlateGrey

XC_SpringGreen

XC_SteelBlue

XC_VioletRed

XC_WhiteSmoke

XC_YellowGreen

XC_aquamarine

XC_azure

XC_beige

XC_bisque

XC_AliceBlue

XC_blue

XC_blue1

XC_blue2

XC_blue3

XC_blue4

XC_brown

XC_burlywood

XC_chartreuse

XC_chocolate

XC_coral

XC_cornsilk

XC_cyan

XC_firebrick

XC_gainsboro

XC_gold

XC_goldenrod

XC_gray

XC_gray0

XC_gray10

XC_gray100

XC_gray20

XC_gray30

XC_gray40

XC_gray50

XC_gray60

XC_gray70

XC_gray80

XC_gray90

XC_green

XC_green1

XC_green2

XC_green3

XC_green4

XC_honeydew

XC_ivory

XC_khaki

XC_lavender

XC_linen

XC_magenta

XC_maroon

XC_moccasin

XC_navy

XC_orange

XC_orchid

XC_peru

XC_pink

XC_plum

XC_purple

XC_red

XC_red1

XC_red2

XC_red3

XC_red4

XC_salmon

XC_seashell

XC_sienna

XC_snow

XC_snow1

XC_snow2

XC_snow3

XC_snow4

XC_tan

XC_thistle

XC_tomato

XC_turquoise

XC_violet

XC_wheat

XC_white

XC_yellow

XC_last_color

pyrosetta.rosetta.protocols.moves.complex_type_name_for_mover(mover_name: str) → str

C++: protocols::moves::complex_type_name_for_mover(const class std::basic_string<char> &) –> std::string

pyrosetta.rosetta.protocols.moves.find_filter_or_die(filter_name: str, tag: pyrosetta.rosetta.utility.tag.Tag, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t) → pyrosetta.rosetta.protocols.filters.Filter

Searches <filters> for the named filter, returning it if it exists,

otherwise halts execution with an error message.

C++: protocols::moves::find_filter_or_die(const class std::basic_string<char> &, class std::shared_ptr<const class utility::tag::Tag>, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &) –> class std::shared_ptr<class protocols::filters::Filter>

pyrosetta.rosetta.protocols.moves.find_mover_or_die(mover_name: str, tag: pyrosetta.rosetta.utility.tag.Tag, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t) → pyrosetta.rosetta.protocols.moves.Mover

Searches <movers> for the named mover, returning it if it exists,

otherwise halts execution with an error message.

C++: protocols::moves::find_mover_or_die(const class std::basic_string<char> &, class std::shared_ptr<const class utility::tag::Tag>, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &) –> class std::shared_ptr<class protocols::moves::Mover>

pyrosetta.rosetta.protocols.moves.get_pymol_observer(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.moves.PyMOLObserver

(Internal) helper function to create a PyMOLObserver and add it to the given pose

NOTE: You NEED to adjust the observer type and call attach() on the return - by default a new PyMOLObserver isn’t attached/observing.

C++: protocols::moves::get_pymol_observer(class core::pose::Pose &) –> class std::shared_ptr<class protocols::moves::PyMOLObserver>

pyrosetta.rosetta.protocols.moves.mstype_from_name(name: str) → pyrosetta.rosetta.protocols.moves.MoverStatus

C++: protocols::moves::mstype_from_name(const class std::basic_string<char> &) –> enum protocols::moves::MoverStatus

pyrosetta.rosetta.protocols.moves.to_string(mc_accepted: pyrosetta.rosetta.protocols.moves.MCA) → str

C++: protocols::moves::to_string(const enum protocols::moves::MCA &) –> std::string

pyrosetta.rosetta.protocols.moves.xsd_type_definition_w_attributes(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, mover_type: str, description: str, attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

Define the XML schema definition for a Mover that

contains no subtags but may contain any number of attributes (aka options).

C++: protocols::moves::xsd_type_definition_w_attributes(class utility::tag::XMLSchemaDefinition &, const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

pyrosetta.rosetta.protocols.moves.xsd_type_definition_w_attributes_and_repeatable_subelements(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, mover_type: str, description: str, attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) → None

Define the XML schema definition for a Mover that

contains subtags attributes (aka options).

C++: protocols::moves::xsd_type_definition_w_attributes_and_repeatable_subelements(class utility::tag::XMLSchemaDefinition &, const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class utility::tag::XMLSchemaSimpleSubelementList &) –> void