enzdes

• enzutil

Bindings for protocols::enzdes namespace

class pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts

Bases: pyrosetta.rosetta.protocols.moves.Mover

A simple wrapper to get the functionality in EnzConstraintIO into mover format

apply(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::AddOrRemoveMatchCsts::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts, : pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts) → pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts

C++: protocols::enzdes::AddOrRemoveMatchCsts::operator=(const class protocols::enzdes::AddOrRemoveMatchCsts &) –> class protocols::enzdes::AddOrRemoveMatchCsts &

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

C++: protocols::enzdes::AddOrRemoveMatchCsts::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>

cstfile(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts, setting: str) → None

C++: protocols::enzdes::AddOrRemoveMatchCsts::cstfile(const class std::basic_string<char> &) –> void

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

C++: protocols::enzdes::AddOrRemoveMatchCsts::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_const_EnzConstraintIO_for_cstfile(*args, **kwargs)

Overloaded function.

1. get_const_EnzConstraintIO_for_cstfile() -> protocols::toolbox::match_enzdes_util::EnzConstraintIO
2. get_const_EnzConstraintIO_for_cstfile(cstfile: str) -> protocols::toolbox::match_enzdes_util::EnzConstraintIO

C++: protocols::enzdes::AddOrRemoveMatchCsts::get_const_EnzConstraintIO_for_cstfile(class std::basic_string<char>) –> class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::EnzConstraintIO>

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.enzdes.AddOrRemoveMatchCsts) → str

C++: protocols::enzdes::AddOrRemoveMatchCsts::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

mover_name() → str

C++: protocols::enzdes::AddOrRemoveMatchCsts::mover_name() –> std::string

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts, 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::enzdes::AddOrRemoveMatchCsts::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::enzdes::AddOrRemoveMatchCsts::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_accept_blocks_missing_header(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts, setting: bool) → None

C++: protocols::enzdes::AddOrRemoveMatchCsts::set_accept_blocks_missing_header(bool) –> void

set_cst_action(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts, action: pyrosetta.rosetta.protocols.enzdes.CstAction) → None

C++: protocols::enzdes::AddOrRemoveMatchCsts::set_cst_action(enum protocols::enzdes::CstAction) –> 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_keep_covalent(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts, setting: bool) → None

C++: protocols::enzdes::AddOrRemoveMatchCsts::set_keep_covalent(bool) –> 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.enzdes.ApplyRandomStoredRBConf

Bases: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs

for every ligand that has additional stored rb conformations in the enzdes cacheable observer, the one currently in the pose gets exchanged with a random stored one

apply(self: pyrosetta.rosetta.protocols.enzdes.ApplyRandomStoredRBConf, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::ApplyRandomStoredRBConf::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.ApplyRandomStoredRBConf, : pyrosetta.rosetta.protocols.enzdes.ApplyRandomStoredRBConf) → pyrosetta.rosetta.protocols.enzdes.ApplyRandomStoredRBConf

C++: protocols::enzdes::ApplyRandomStoredRBConf::operator=(const class protocols::enzdes::ApplyRandomStoredRBConf &) –> class protocols::enzdes::ApplyRandomStoredRBConf &

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>

closest_orient_atoms_msd(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, confs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → pyrosetta.rosetta.utility.vector1_double

calculates the closest orient atom (i.e. atoms used in rotamer placement

msd between every conf and the confs coming before it in the pose or in the vector

C++: protocols::enzdes::ModifyStoredRBConfs::closest_orient_atoms_msd(const class core::pose::Pose &, const class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > > &) const –> class utility::vector1<double, class std::allocator<double> >

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.enzdes.ApplyRandomStoredRBConf) → str

C++: protocols::enzdes::ApplyRandomStoredRBConf::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

swap_coordinates_in_pose(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, rescoords: pyrosetta.rosetta.core.conformation.Residue) → None

helper function to exchange coordinates in a pose

this function doesn’t actually exchange the residues, but sets all the coords of pose.residue( rescoords.seqpos() ) to what is in rescoords and vice versa

C++: protocols::enzdes::ModifyStoredRBConfs::swap_coordinates_in_pose(class core::pose::Pose &, class core::conformation::Residue &) 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.enzdes.CstAction

Bases: pybind11_builtins.pybind11_object

Members:

_VOID

ADD_NEW

ADD_PREGENERATED

REMOVE

class pyrosetta.rosetta.protocols.enzdes.DesignVsNativeComparison

Bases: pybind11_builtins.pybind11_object

class that holds a bunch of native poses and compares them

against a given input pose on request

assign(self: pyrosetta.rosetta.protocols.enzdes.DesignVsNativeComparison, : pyrosetta.rosetta.protocols.enzdes.DesignVsNativeComparison) → pyrosetta.rosetta.protocols.enzdes.DesignVsNativeComparison

C++: protocols::enzdes::DesignVsNativeComparison::operator=(const class protocols::enzdes::DesignVsNativeComparison &) –> class protocols::enzdes::DesignVsNativeComparison &

compare_to_native(self: pyrosetta.rosetta.protocols.enzdes.DesignVsNativeComparison, pose: pyrosetta.rosetta.core.pose.Pose, calculators: pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_string_t, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, silent_Es: pyrosetta.rosetta.utility.vector1_core_io_silent_SilentEnergy) → None

C++: protocols::enzdes::DesignVsNativeComparison::compare_to_native(const class core::pose::Pose &, const class utility::vector1<struct std::pair<class std::basic_string<char>, class std::basic_string<char> >, class std::allocator<struct std::pair<class std::basic_string<char>, class std::basic_string<char> > > > &, class std::shared_ptr<const class core::scoring::ScoreFunction>, class utility::vector1<class core::io::silent::SilentEnergy, class std::allocator<class core::io::silent::SilentEnergy> > &) –> void

class pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

Given a set of cut1/cut2/cut3/cut4 distance specifications, alter a packing task to set residues within alpha carbons within cut1 of a ligand (or within cut2 with beta carbons facing inwards) to redesign, and within cut3 (or cut4 facing inwards) to repack, and all others to fixed. If a resfile is provided, only do the detection for those residues set to AUTO in the resfile.

add_observer_cache_segments_to_set(pose: pyrosetta.rosetta.core.pose.Pose, set: pyrosetta.rosetta.std.set_unsigned_long_t) → None

C++: protocols::enzdes::DetectProteinLigandInterface::add_observer_cache_segments_to_set(const class core::pose::Pose &, class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &) –> void

apply(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None

Change a packer task in some way. The input pose is the one to which the input

task will be later applied.

C++: protocols::enzdes::DetectProteinLigandInterface::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface, : pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface) → pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface

C++: protocols::enzdes::DetectProteinLigandInterface::operator=(const class protocols::enzdes::DetectProteinLigandInterface &) –> class protocols::enzdes::DetectProteinLigandInterface &

clone(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation

C++: protocols::enzdes::DetectProteinLigandInterface::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

find_design_interface(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface, pose: pyrosetta.rosetta.core.pose.Pose, interface_target_res: pyrosetta.rosetta.std.set_unsigned_long_t, cut1: float, cut2: float, cut3: float, cut4: float, repack_res: pyrosetta.rosetta.utility.vector1_bool, design_res: pyrosetta.rosetta.utility.vector1_bool) → None

C++: protocols::enzdes::DetectProteinLigandInterface::find_design_interface(const class core::pose::Pose &, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, double, double, double, double, class utility::vector1<bool, class std::allocator<bool> > &, class utility::vector1<bool, class std::allocator<bool> > &) const –> void

find_design_interface_arg_sweep(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface, pose: pyrosetta.rosetta.core.pose.Pose, interface_target_res: pyrosetta.rosetta.std.set_unsigned_long_t, cut1: float, cut2: float, cut3: float, cut4: float, arg_sweep_cutoff: float, repack_res: pyrosetta.rosetta.utility.vector1_bool, design_res: pyrosetta.rosetta.utility.vector1_bool) → None

C++: protocols::enzdes::DetectProteinLigandInterface::find_design_interface_arg_sweep(const class core::pose::Pose &, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, double, double, double, double, double, class utility::vector1<bool, class std::allocator<bool> > &, class utility::vector1<bool, class std::allocator<bool> > &) const –> void

get_design(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface) → bool

C++: protocols::enzdes::DetectProteinLigandInterface::get_design() const –> bool

get_no_design_cys(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface) → bool

C++: protocols::enzdes::DetectProteinLigandInterface::get_no_design_cys() const –> bool

init_from_options(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface) → None

Initialize the class based on the command line options.

C++: protocols::enzdes::DetectProteinLigandInterface::init_from_options() –> void

keyname() → str

C++: protocols::enzdes::DetectProteinLigandInterface::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None

C++: protocols::enzdes::DetectProteinLigandInterface::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

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

C++: protocols::enzdes::DetectProteinLigandInterface::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

C++: protocols::enzdes::DetectProteinLigandInterface::register_options() –> void

set_design(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface, design_in: bool) → None

C++: protocols::enzdes::DetectProteinLigandInterface::set_design(const bool) –> void

set_design_target_res(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface, target_res: pyrosetta.rosetta.std.set_unsigned_long_t) → None

C++: protocols::enzdes::DetectProteinLigandInterface::set_design_target_res(const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &) –> void

set_no_design_cys(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface, no_design_cys_in: bool) → None

C++: protocols::enzdes::DetectProteinLigandInterface::set_no_design_cys(const bool) –> void

class pyrosetta.rosetta.protocols.enzdes.DiversifyStoredRBConfs

Bases: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs

uses a docking mover to diversiy the stored confs until they’re all min_rms_ away from each other note: no scorefunction used here

apply(self: pyrosetta.rosetta.protocols.enzdes.DiversifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::DiversifyStoredRBConfs::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.DiversifyStoredRBConfs, : pyrosetta.rosetta.protocols.enzdes.DiversifyStoredRBConfs) → pyrosetta.rosetta.protocols.enzdes.DiversifyStoredRBConfs

C++: protocols::enzdes::DiversifyStoredRBConfs::operator=(const class protocols::enzdes::DiversifyStoredRBConfs &) –> class protocols::enzdes::DiversifyStoredRBConfs &

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>

closest_orient_atoms_msd(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, confs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → pyrosetta.rosetta.utility.vector1_double

calculates the closest orient atom (i.e. atoms used in rotamer placement

msd between every conf and the confs coming before it in the pose or in the vector

C++: protocols::enzdes::ModifyStoredRBConfs::closest_orient_atoms_msd(const class core::pose::Pose &, const class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > > &) const –> class utility::vector1<double, class std::allocator<double> >

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>

diversify_all_confs(self: pyrosetta.rosetta.protocols.enzdes.DiversifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, confs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → None

C++: protocols::enzdes::DiversifyStoredRBConfs::diversify_all_confs(const class core::pose::Pose &, class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > > &) const –> void

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

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

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

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

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

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

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

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

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

A tag is a unique identifier used to identify structures produced

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

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

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

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

get_last_move_status(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.MoverStatus

returns status after an apply(). The job distributor (august 08 vintage) will check this function to see if your protocol wants to filter its results - if your protocol wants to say “that run was no good, skip it” then use the protected last_move_status(MoverStatus) to change the value that this function will return.

C++: protocols::moves::Mover::get_last_move_status() const –> enum protocols::moves::MoverStatus

get_name(self: pyrosetta.rosetta.protocols.enzdes.DiversifyStoredRBConfs) → str

C++: protocols::enzdes::DiversifyStoredRBConfs::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

swap_coordinates_in_pose(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, rescoords: pyrosetta.rosetta.core.conformation.Residue) → None

helper function to exchange coordinates in a pose

this function doesn’t actually exchange the residues, but sets all the coords of pose.residue( rescoords.seqpos() ) to what is in rescoords and vice versa

C++: protocols::enzdes::ModifyStoredRBConfs::swap_coordinates_in_pose(class core::pose::Pose &, class core::conformation::Residue &) 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.enzdes.EnzdesJobOutputter

Bases: pyrosetta.rosetta.protocols.jd2.PDBJobOutputter

for now this class only writes a different scorefile

than the default one written by the FileJobOutputter. the structure output format is pdb

SML Feb 4 2016 note. I moved most of PDBJobOutputter into an intermediate class wwPDBJobOutputter to share functions with mmCIFJobOutputter. This class is not being modified (doesn’t appear to need it). Its use of dump_pdb forces that function to be protected rather than private.

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None

C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, class std::basic_string<char>, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator

C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, data: str) → None

this function takes a string and writes it to disk (separately from Tracer output).

C++: protocols::jd2::FileJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const class std::basic_string<char> &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str

C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) → None

C++: protocols::enzdes::EnzdesJobOutputter::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobOutputter, job: protocols::jd2::Job) → bool

C++: protocols::enzdes::EnzdesJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

other_pose(*args, **kwargs)

Overloaded function.

1. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
2. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
3. other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol. This implementation will write a wwPDB-format file (plus scores). It calls a pure virtual so that child classes can write PDB or mmCIF format.

C++: protocols::jd2::wwPDBJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const class std::basic_string<char> &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job) → str

this is the master function for determining the unique output identifier for a job

C++: protocols::jd2::wwPDBJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

scorefile_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → pyrosetta.rosetta.utility.file.FileName

C++: protocols::jd2::FileJobOutputter::scorefile_name() –> const class utility::file::FileName &

set_defaults(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → None

C++: protocols::jd2::FileJobOutputter::set_defaults() –> void

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

starting_pose(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.core.pose.Pose) → None

optionally pass a starting (reference) pose to a JobOutputter for later comparison

purposes and/or as interface for initializing evaluators

C++: protocols::jd2::JobOutputter::starting_pose(const class core::pose::Pose &) –> void

write_scorefile(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → bool

C++: protocols::jd2::FileJobOutputter::write_scorefile() const –> bool

class pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

brief Class that calculates silent energies for an enzdes type scorefile these silent energies can then be written into a scorefile. class is derived from Filter because eventually it should be possible to have this class read in a requirement file and return false if any of the silent energies don’t have the required value

apply(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::enzdes::EnzdesScorefileFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::enzdes::EnzdesScorefileFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clear_rnl_pose(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter) → None

clear rnl pose to save some memory

C++: protocols::enzdes::EnzdesScorefileFilter::clear_rnl_pose() –> void

clone(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::enzdes::EnzdesScorefileFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

examine_pose(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::EnzdesScorefileFilter::examine_pose(const class core::pose::Pose &) const –> void

fresh_instance(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::enzdes::EnzdesScorefileFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter) → str

C++: protocols::enzdes::EnzdesScorefileFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter, 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, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

report(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::filters::Filter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::report_sm(const class core::pose::Pose &) const –> double

rnl_pose(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::enzdes::EnzdesScorefileFilter::rnl_pose() –> class std::shared_ptr<class core::pose::Pose>

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_cstio(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter, enzcst_io: protocols::toolbox::match_enzdes_util::EnzConstraintIO) → None

C++: protocols::enzdes::EnzdesScorefileFilter::set_cstio(class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::EnzConstraintIO>) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

silent_Es(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter) → pyrosetta.rosetta.utility.vector1_core_io_silent_SilentEnergy

C++: protocols::enzdes::EnzdesScorefileFilter::silent_Es() const –> const class utility::vector1<class core::io::silent::SilentEnergy, class std::allocator<class core::io::silent::SilentEnergy> > &

class pyrosetta.rosetta.protocols.enzdes.GenerateStoredRBConfs

Bases: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs

generates random rbconfs until a total of num_total_rbconfs_ are present in the cacheable observer. The diversifier is used to ensure that all newly generated confs are different. note: no scorefunction used

apply(self: pyrosetta.rosetta.protocols.enzdes.GenerateStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::GenerateStoredRBConfs::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.GenerateStoredRBConfs, : pyrosetta.rosetta.protocols.enzdes.GenerateStoredRBConfs) → pyrosetta.rosetta.protocols.enzdes.GenerateStoredRBConfs

C++: protocols::enzdes::GenerateStoredRBConfs::operator=(const class protocols::enzdes::GenerateStoredRBConfs &) –> class protocols::enzdes::GenerateStoredRBConfs &

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>

closest_orient_atoms_msd(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, confs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → pyrosetta.rosetta.utility.vector1_double

calculates the closest orient atom (i.e. atoms used in rotamer placement

msd between every conf and the confs coming before it in the pose or in the vector

C++: protocols::enzdes::ModifyStoredRBConfs::closest_orient_atoms_msd(const class core::pose::Pose &, const class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > > &) const –> class utility::vector1<double, class std::allocator<double> >

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.enzdes.GenerateStoredRBConfs) → str

C++: protocols::enzdes::GenerateStoredRBConfs::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

swap_coordinates_in_pose(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, rescoords: pyrosetta.rosetta.core.conformation.Residue) → None

helper function to exchange coordinates in a pose

this function doesn’t actually exchange the residues, but sets all the coords of pose.residue( rescoords.seqpos() ) to what is in rescoords and vice versa

C++: protocols::enzdes::ModifyStoredRBConfs::swap_coordinates_in_pose(class core::pose::Pose &, class core::conformation::Residue &) 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.enzdes.MinimizeStoredRBConfs

Bases: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs

rotamer trials/minimizes each of the ligand conformations stored in the enzdes cacheable observer and overwrites them with the minimized position. if the new, minimized position is too close to one that already exists,

a random small perturbation is applied to ensure diversity

note: only jump minimization

apply(self: pyrosetta.rosetta.protocols.enzdes.MinimizeStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::MinimizeStoredRBConfs::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.MinimizeStoredRBConfs, : pyrosetta.rosetta.protocols.enzdes.MinimizeStoredRBConfs) → pyrosetta.rosetta.protocols.enzdes.MinimizeStoredRBConfs

C++: protocols::enzdes::MinimizeStoredRBConfs::operator=(const class protocols::enzdes::MinimizeStoredRBConfs &) –> class protocols::enzdes::MinimizeStoredRBConfs &

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>

closest_orient_atoms_msd(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, confs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → pyrosetta.rosetta.utility.vector1_double

calculates the closest orient atom (i.e. atoms used in rotamer placement

msd between every conf and the confs coming before it in the pose or in the vector

C++: protocols::enzdes::ModifyStoredRBConfs::closest_orient_atoms_msd(const class core::pose::Pose &, const class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > > &) const –> class utility::vector1<double, class std::allocator<double> >

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.enzdes.MinimizeStoredRBConfs) → str

C++: protocols::enzdes::MinimizeStoredRBConfs::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

rb_minimize_all_confs(self: pyrosetta.rosetta.protocols.enzdes.MinimizeStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, confs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → None

C++: protocols::enzdes::MinimizeStoredRBConfs::rb_minimize_all_confs(const class core::pose::Pose &, class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > > &) const –> 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

swap_coordinates_in_pose(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, rescoords: pyrosetta.rosetta.core.conformation.Residue) → None

helper function to exchange coordinates in a pose

this function doesn’t actually exchange the residues, but sets all the coords of pose.residue( rescoords.seqpos() ) to what is in rescoords and vice versa

C++: protocols::enzdes::ModifyStoredRBConfs::swap_coordinates_in_pose(class core::pose::Pose &, class core::conformation::Residue &) 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.enzdes.ModifyStoredRBConfs

Bases: pyrosetta.rosetta.protocols.moves.Mover

virtual base class that has some common functionality

apply(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::ModifyStoredRBConfs::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, : pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs) → pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs

C++: protocols::enzdes::ModifyStoredRBConfs::operator=(const class protocols::enzdes::ModifyStoredRBConfs &) –> class protocols::enzdes::ModifyStoredRBConfs &

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>

closest_orient_atoms_msd(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, confs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → pyrosetta.rosetta.utility.vector1_double

calculates the closest orient atom (i.e. atoms used in rotamer placement

msd between every conf and the confs coming before it in the pose or in the vector

C++: protocols::enzdes::ModifyStoredRBConfs::closest_orient_atoms_msd(const class core::pose::Pose &, const class utility::vector1<class std::shared_ptr<const class core::conformation::Residue>, class std::allocator<class std::shared_ptr<const class core::conformation::Residue> > > &) const –> class utility::vector1<double, class std::allocator<double> >

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.enzdes.ModifyStoredRBConfs) → str

C++: protocols::enzdes::ModifyStoredRBConfs::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

swap_coordinates_in_pose(self: pyrosetta.rosetta.protocols.enzdes.ModifyStoredRBConfs, pose: pyrosetta.rosetta.core.pose.Pose, rescoords: pyrosetta.rosetta.core.conformation.Residue) → None

helper function to exchange coordinates in a pose

this function doesn’t actually exchange the residues, but sets all the coords of pose.residue( rescoords.seqpos() ) to what is in rescoords and vice versa

C++: protocols::enzdes::ModifyStoredRBConfs::swap_coordinates_in_pose(class core::pose::Pose &, class core::conformation::Residue &) 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.enzdes.PackRotamersMoverPartGreedy

Bases: pyrosetta.rosetta.protocols.moves.Mover

a mover that packs the side-chains around a given set of target residues in a greedy fashion, and then packs the rest using the sim annealer.

apply(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::PackRotamersMoverPartGreedy::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, : pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy) → pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy

C++: protocols::enzdes::PackRotamersMoverPartGreedy::operator=(const class protocols::enzdes::PackRotamersMoverPartGreedy &) –> class protocols::enzdes::PackRotamersMoverPartGreedy &

choose_n_best(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, pose: pyrosetta.rosetta.core.pose.Pose, n_best: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::enzdes::PackRotamersMoverPartGreedy::choose_n_best(const class core::pose::Pose &, const unsigned long &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

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

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

compute_designable_neighbors(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, position: int, task: pyrosetta.rosetta.core.pack.task.PackerTask, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::enzdes::PackRotamersMoverPartGreedy::compute_designable_neighbors(const unsigned long &, class std::shared_ptr<const class core::pack::task::PackerTask>, const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

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

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

C++: protocols::enzdes::PackRotamersMoverPartGreedy::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

greedy_around(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, pose: pyrosetta.rosetta.core.pose.Pose, target_res: pyrosetta.rosetta.utility.vector1_unsigned_long, task: pyrosetta.rosetta.core.pack.task.PackerTask, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::enzdes::PackRotamersMoverPartGreedy::greedy_around(class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class std::shared_ptr<class core::pack::task::PackerTask>, class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

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::enzdes::PackRotamersMoverPartGreedy::mover_name() –> std::string

name() → str

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

parse_my_tag(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, 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, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::PackRotamersMoverPartGreedy::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::enzdes::PackRotamersMoverPartGreedy::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

target_residues(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, trg_res: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

C++: protocols::enzdes::PackRotamersMoverPartGreedy::target_residues(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

task(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None

C++: protocols::enzdes::PackRotamersMoverPartGreedy::task(class std::shared_ptr<class core::pack::task::PackerTask>) –> void

task_factory(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, p: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

C++: protocols::enzdes::PackRotamersMoverPartGreedy::task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> 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

update_task_and_neighbors(self: pyrosetta.rosetta.protocols.enzdes.PackRotamersMoverPartGreedy, best_neigh: int, task: pyrosetta.rosetta.core.pack.task.PackerTask, current_neighbors: pyrosetta.rosetta.utility.vector1_unsigned_long) → None

C++: protocols::enzdes::PackRotamersMoverPartGreedy::update_task_and_neighbors(const unsigned long &, class std::shared_ptr<class core::pack::task::PackerTask>, class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

class pyrosetta.rosetta.protocols.enzdes.PoseFoundResiduesCombination

Bases: pybind11_builtins.pybind11_object

helper class to process and output the different found poses

add_residue(self: pyrosetta.rosetta.protocols.enzdes.PoseFoundResiduesCombination, res_in: pyrosetta.rosetta.core.conformation.Residue) → None

C++: protocols::enzdes::PoseFoundResiduesCombination::add_residue(class std::shared_ptr<class core::conformation::Residue>) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.PoseFoundResiduesCombination, : pyrosetta.rosetta.protocols.enzdes.PoseFoundResiduesCombination) → pyrosetta.rosetta.protocols.enzdes.PoseFoundResiduesCombination

C++: protocols::enzdes::PoseFoundResiduesCombination::operator=(const class protocols::enzdes::PoseFoundResiduesCombination &) –> class protocols::enzdes::PoseFoundResiduesCombination &

construct_and_dump_outpose(self: pyrosetta.rosetta.protocols.enzdes.PoseFoundResiduesCombination, match_params: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_protocols_toolbox_match_enzdes_util_EnzConstraintParameters_t) → bool

C++: protocols::enzdes::PoseFoundResiduesCombination::construct_and_dump_outpose(class utility::vector1<class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::EnzConstraintParameters>, class std::allocator<class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::EnzConstraintParameters> > >) –> bool

class pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

Class to alter a packer task to speficially upweight the protein-ligand interaction energies

apply(self: pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None

Change a packer task in some way. The input pose is the one to which the input

task will be later applied.

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter, : pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter) → pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::operator=(const class protocols::enzdes::ProteinLigandInterfaceUpweighter &) –> class protocols::enzdes::ProteinLigandInterfaceUpweighter &

clone(self: pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

get_weight(self: pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter) → float

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::get_weight() const –> double

init_from_options(self: pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter) → None

Initialize the class based on the command line options.

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::init_from_options() –> void

keyname() → str

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

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

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::register_options() –> void

set_weight(self: pyrosetta.rosetta.protocols.enzdes.ProteinLigandInterfaceUpweighter, weight_in: float) → None

C++: protocols::enzdes::ProteinLigandInterfaceUpweighter::set_weight(const double) –> void

class pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

class that will identify the region around the ligand, remove it, and then do a repack. It can also calculate the following parameters: E diff after the repack, (in essence a crude delta G calc) rmsd of the repacked site after the repack and rmsd of catalytic residues

apply(self: pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::RepackLigandSiteWithoutLigandMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover, : pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover) → pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover

C++: protocols::enzdes::RepackLigandSiteWithoutLigandMover::operator=(const class protocols::enzdes::RepackLigandSiteWithoutLigandMover &) –> class protocols::enzdes::RepackLigandSiteWithoutLigandMover &

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.enzdes.RepackLigandSiteWithoutLigandMover) → str

C++: protocols::enzdes::RepackLigandSiteWithoutLigandMover::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_ptask(self: pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: protocols::enzdes::RepackLigandSiteWithoutLigandMover::get_ptask() const –> class std::shared_ptr<const class core::pack::task::PackerTask>

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_calculate_silent_Es(self: pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover, calculate: bool) → None

C++: protocols::enzdes::RepackLigandSiteWithoutLigandMover::set_calculate_silent_Es(bool) –> void

set_cstio(self: pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover, enzcst_io: pyrosetta.rosetta.protocols.toolbox.match_enzdes_util.EnzConstraintIO) → None

C++: protocols::enzdes::RepackLigandSiteWithoutLigandMover::set_cstio(class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::EnzConstraintIO>) –> 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_separate_prt_ligand(self: pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover, separate_prt_ligand: bool) → None

C++: protocols::enzdes::RepackLigandSiteWithoutLigandMover::set_separate_prt_ligand(bool) –> void

set_sfxn(self: pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::enzdes::RepackLigandSiteWithoutLigandMover::set_sfxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> 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

silent_Es(self: pyrosetta.rosetta.protocols.enzdes.RepackLigandSiteWithoutLigandMover) → pyrosetta.rosetta.utility.vector1_core_io_silent_SilentEnergy

C++: protocols::enzdes::RepackLigandSiteWithoutLigandMover::silent_Es() –> const class utility::vector1<class core::io::silent::SilentEnergy, class std::allocator<class core::io::silent::SilentEnergy> > &

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.enzdes.ResidueConformerFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

filter that figures out which rotamer of a given rotamer lib is in the pose at apply time, and can be used to filter on it. supposed to be used for ligands, and for now only tested for them, but should also work with any other residue. can be used for example in specificity redesign, if one wants to divide up a bunch of designs according to the orientation in which they bind the ligand

apply(self: pyrosetta.rosetta.protocols.enzdes.ResidueConformerFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::enzdes::ResidueConformerFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::enzdes::ResidueConformerFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.enzdes.ResidueConformerFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::enzdes::ResidueConformerFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

fresh_instance(self: pyrosetta.rosetta.protocols.enzdes.ResidueConformerFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::enzdes::ResidueConformerFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_current_conformer(self: pyrosetta.rosetta.protocols.enzdes.ResidueConformerFilter, pose: pyrosetta.rosetta.core.pose.Pose) → int

C++: protocols::enzdes::ResidueConformerFilter::get_current_conformer(const class core::pose::Pose &) const –> unsigned long

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.enzdes.ResidueConformerFilter) → str

C++: protocols::enzdes::ResidueConformerFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.enzdes.ResidueConformerFilter, 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, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

report(self: pyrosetta.rosetta.protocols.enzdes.ResidueConformerFilter, : pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::ResidueConformerFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.enzdes.ResidueConformerFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::enzdes::ResidueConformerFilter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.enzdes.SetCatalyticResPackBehavior

Bases: pyrosetta.rosetta.core.pack.task.operation.TaskOperation

queries the pose cst cache for the catalytic residues, and sets the behavior for them as specified in the cstfile

apply(self: pyrosetta.rosetta.protocols.enzdes.SetCatalyticResPackBehavior, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None

Change a packer task in some way. The input pose is the one to which the input

task will be later applied.

C++: protocols::enzdes::SetCatalyticResPackBehavior::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.SetCatalyticResPackBehavior, : pyrosetta.rosetta.protocols.enzdes.SetCatalyticResPackBehavior) → pyrosetta.rosetta.protocols.enzdes.SetCatalyticResPackBehavior

C++: protocols::enzdes::SetCatalyticResPackBehavior::operator=(const class protocols::enzdes::SetCatalyticResPackBehavior &) –> class protocols::enzdes::SetCatalyticResPackBehavior &

clone(self: pyrosetta.rosetta.protocols.enzdes.SetCatalyticResPackBehavior) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation

C++: protocols::enzdes::SetCatalyticResPackBehavior::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname() → str

C++: protocols::enzdes::SetCatalyticResPackBehavior::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.enzdes.SetCatalyticResPackBehavior, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None

C++: protocols::enzdes::SetCatalyticResPackBehavior::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

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

C++: protocols::enzdes::SetCatalyticResPackBehavior::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_fix_catalytic_aa(self: pyrosetta.rosetta.protocols.enzdes.SetCatalyticResPackBehavior, setting: bool) → None

C++: protocols::enzdes::SetCatalyticResPackBehavior::set_fix_catalytic_aa(bool) –> void

class pyrosetta.rosetta.protocols.enzdes.UpdateEnzdesHeaderMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

mover that updates the enzdes pdb header, for use in cases where catalytic residues may be designed

apply(self: pyrosetta.rosetta.protocols.enzdes.UpdateEnzdesHeaderMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::enzdes::UpdateEnzdesHeaderMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.UpdateEnzdesHeaderMover, : pyrosetta.rosetta.protocols.enzdes.UpdateEnzdesHeaderMover) → pyrosetta.rosetta.protocols.enzdes.UpdateEnzdesHeaderMover

C++: protocols::enzdes::UpdateEnzdesHeaderMover::operator=(const class protocols::enzdes::UpdateEnzdesHeaderMover &) –> class protocols::enzdes::UpdateEnzdesHeaderMover &

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

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

C++: protocols::enzdes::UpdateEnzdesHeaderMover::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

mover_name() → str

C++: protocols::enzdes::UpdateEnzdesHeaderMover::mover_name() –> std::string

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

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

C++: protocols::enzdes::UpdateEnzdesHeaderMover::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

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.enzdes.ValueEvaluator

Bases: pybind11_builtins.pybind11_object

tiny helper struct for EnzdesScoreFileFilter

class CompareMode

Bases: pybind11_builtins.pybind11_object

Members:

SMALLER

LARGER

EQUALS

value_passes(self: pyrosetta.rosetta.protocols.enzdes.ValueEvaluator, value: float) → bool

C++: protocols::enzdes::ValueEvaluator::value_passes(const double) const –> bool