enzdes¶

enzutil

Bindings for protocols::enzdes namespace

class pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamers¶

Bases: TaskOperation

apply(self: pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamers, : pyrosetta.rosetta.core.pose.Pose, : 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::AddLigandMotifRotamers::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamers, : pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamers) → pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamers¶: C++: protocols::enzdes::AddLigandMotifRotamers::operator=(const class protocols::enzdes::AddLigandMotifRotamers &) –> class protocols::enzdes::AddLigandMotifRotamers &

clone(self: pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamers) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::enzdes::AddLigandMotifRotamers::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

static keyname() → str¶: C++: protocols::enzdes::AddLigandMotifRotamers::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamers, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::enzdes::AddLigandMotifRotamers::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by task operations wishing to provide citation information.

C++: core::pack::task::operation::TaskOperation::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::AddLigandMotifRotamers::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static register_options() → None¶: C++: protocols::enzdes::AddLigandMotifRotamers::register_options() –> void

class pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamersOperationCreator¶

Bases: TaskOperationCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamersOperationCreator, : pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamersOperationCreator) → pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamersOperationCreator¶: C++: protocols::enzdes::AddLigandMotifRotamersOperationCreator::operator=(const class protocols::enzdes::AddLigandMotifRotamersOperationCreator &) –> class protocols::enzdes::AddLigandMotifRotamersOperationCreator &

create_task_operation(self: pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamersOperationCreator) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::enzdes::AddLigandMotifRotamersOperationCreator::create_task_operation() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname(self: pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamersOperationCreator) → str¶: C++: protocols::enzdes::AddLigandMotifRotamersOperationCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.enzdes.AddLigandMotifRotamersOperationCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::AddLigandMotifRotamersOperationCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

skip_citation_info_in_schema(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperationCreator) → bool¶

Indicate whether we skip adding citation information to the XML schema.

False for any real task operation. True only for dummy task operations created for unit tests.

C++: core::pack::task::operation::TaskOperationCreator::skip_citation_info_in_schema() const –> bool

class pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCsts¶

Bases: 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 std::string &) –> 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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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

static get_const_EnzConstraintIO_for_cstfile(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::enzdes::AddOrRemoveMatchCsts::get_const_EnzConstraintIO_for_cstfile(std::string) –> 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_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

static mover_name() → str¶: C++: protocols::enzdes::AddOrRemoveMatchCsts::mover_name() –> std::string

static 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) → None¶: C++: protocols::enzdes::AddOrRemoveMatchCsts::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::AddOrRemoveMatchCsts::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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¶: 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 std::string &) –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCstsCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCstsCreator, : pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCstsCreator) → pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCstsCreator¶: C++: protocols::enzdes::AddOrRemoveMatchCstsCreator::operator=(const class protocols::enzdes::AddOrRemoveMatchCstsCreator &) –> class protocols::enzdes::AddOrRemoveMatchCstsCreator &

create_mover(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCstsCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::enzdes::AddOrRemoveMatchCstsCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCstsCreator) → str¶: C++: protocols::enzdes::AddOrRemoveMatchCstsCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.enzdes.AddOrRemoveMatchCstsCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::AddOrRemoveMatchCstsCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfs¶

Bases: TaskOperation

apply(self: pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfs, : pyrosetta.rosetta.core.pose.Pose, : 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::AddRigidBodyLigandConfs::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfs, : pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfs) → pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfs¶: C++: protocols::enzdes::AddRigidBodyLigandConfs::operator=(const class protocols::enzdes::AddRigidBodyLigandConfs &) –> class protocols::enzdes::AddRigidBodyLigandConfs &

clone(self: pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfs) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::enzdes::AddRigidBodyLigandConfs::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

static keyname() → str¶: C++: protocols::enzdes::AddRigidBodyLigandConfs::keyname() –> std::string

parse_tag(self: pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfs, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::enzdes::AddRigidBodyLigandConfs::parse_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by task operations wishing to provide citation information.

C++: core::pack::task::operation::TaskOperation::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::AddRigidBodyLigandConfs::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfsCreator¶

Bases: TaskOperationCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfsCreator, : pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfsCreator) → pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfsCreator¶: C++: protocols::enzdes::AddRigidBodyLigandConfsCreator::operator=(const class protocols::enzdes::AddRigidBodyLigandConfsCreator &) –> class protocols::enzdes::AddRigidBodyLigandConfsCreator &

create_task_operation(self: pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfsCreator) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::enzdes::AddRigidBodyLigandConfsCreator::create_task_operation() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname(self: pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfsCreator) → str¶: C++: protocols::enzdes::AddRigidBodyLigandConfsCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.enzdes.AddRigidBodyLigandConfsCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::AddRigidBodyLigandConfsCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

skip_citation_info_in_schema(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperationCreator) → bool¶

Indicate whether we skip adding citation information to the XML schema.

False for any real task operation. True only for dummy task operations created for unit tests.

C++: core::pack::task::operation::TaskOperationCreator::skip_citation_info_in_schema() const –> bool

class pyrosetta.rosetta.protocols.enzdes.ApplyRandomStoredRBConf¶

Bases: 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¶

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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¶

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

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.enzdes.BackboneSampler¶

Bases: LigandBaseProtocol

apply(self: pyrosetta.rosetta.protocols.enzdes.BackboneSampler, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::enzdes::BackboneSampler::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.BackboneSampler, : pyrosetta.rosetta.protocols.enzdes.BackboneSampler) → pyrosetta.rosetta.protocols.enzdes.BackboneSampler¶: C++: protocols::enzdes::BackboneSampler::operator=(const class protocols::enzdes::BackboneSampler &) –> class protocols::enzdes::BackboneSampler &

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

clear_info is called by jd2 before calling apply

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

clone(self: pyrosetta.rosetta.protocols.enzdes.BackboneSampler) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::enzdes::BackboneSampler::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.enzdes.BackboneSampler) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::enzdes::BackboneSampler::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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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¶

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

static get_ligand_id(*args, **kwargs)¶

Overloaded function.

get_ligand_id(pose: pyrosetta.rosetta.core.pose.Pose) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &) –> unsigned long

get_ligand_id(pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &, unsigned long) –> unsigned long

static get_ligand_jump_id(pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_jump_id(const class core::pose::Pose &) –> unsigned long

get_name(self: pyrosetta.rosetta.protocols.enzdes.BackboneSampler) → str¶: C++: protocols::enzdes::BackboneSampler::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_non_bb_clashing_rotamers(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int, scofx: pyrosetta.rosetta.core.scoring.ScoreFunction, accepted_rotamers: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_non_bb_clashing_rotamers(const class core::pose::Pose &, unsigned long, class std::shared_ptr<const class core::scoring::ScoreFunction>, 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

get_scorefxn(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

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

static mover_name() → str¶: C++: protocols::enzdes::BackboneSampler::mover_name() –> std::string

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::BackboneSampler::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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

reorder_foldtree_around_mobile_regions(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int, mobile_bb: pyrosetta.rosetta.utility.vector1_bool, lig_id: int) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::reorder_foldtree_around_mobile_regions(class core::pose::Pose &, const unsigned long &, const class utility::vector1<bool, class std::allocator<bool> > &, const unsigned long &) const –> void

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

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

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

restrain_protein_Calphas(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, is_restrained: pyrosetta.rosetta.utility.vector1_bool, restr_func: pyrosetta.rosetta.core.scoring.func.Func) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::restrain_protein_Calphas(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class std::shared_ptr<class core::scoring::func::Func>) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> 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¶

Set the ‘type’ string

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

shared_from_this(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol¶: C++: protocols::ligand_docking::LigandBaseProtocol::shared_from_this() –> class std::shared_ptr<class protocols::ligand_docking::LigandBaseProtocol>

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.enzdes.BackboneSamplerCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.BackboneSamplerCreator, : pyrosetta.rosetta.protocols.enzdes.BackboneSamplerCreator) → pyrosetta.rosetta.protocols.enzdes.BackboneSamplerCreator¶: C++: protocols::enzdes::BackboneSamplerCreator::operator=(const class protocols::enzdes::BackboneSamplerCreator &) –> class protocols::enzdes::BackboneSamplerCreator &

create_mover(self: pyrosetta.rosetta.protocols.enzdes.BackboneSamplerCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::enzdes::BackboneSamplerCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.enzdes.BackboneSamplerCreator) → str¶: C++: protocols::enzdes::BackboneSamplerCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.enzdes.BackboneSamplerCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::BackboneSamplerCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.enzdes.CstAction¶

Bases: pybind11_object

Members:

_VOID

ADD_NEW

ADD_PREGENERATED

REMOVE

ADD_NEW = <CstAction.ADD_NEW: 2>¶

ADD_PREGENERATED = <CstAction.ADD_PREGENERATED: 3>¶

REMOVE = <CstAction.REMOVE: 4>¶

_VOID = <CstAction._VOID: 1>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.enzdes.DesignVsNativeComparison¶

Bases: 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<std::string, std::string >, class std::allocator<struct std::pair<std::string, std::string > > > &, 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: 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.

static 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_detect_interface(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface) → bool¶: C++: protocols::enzdes::DetectProteinLigandInterface::get_detect_interface() 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

static 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_citation_info(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by task operations wishing to provide citation information.

C++: core::pack::task::operation::TaskOperation::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::DetectProteinLigandInterface::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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_detect_interface(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterface, setting: bool) → None¶: C++: protocols::enzdes::DetectProteinLigandInterface::set_detect_interface(bool) –> 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.DetectProteinLigandInterfaceOperationCreator¶

Bases: TaskOperationCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterfaceOperationCreator, : pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterfaceOperationCreator) → pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterfaceOperationCreator¶: C++: protocols::enzdes::DetectProteinLigandInterfaceOperationCreator::operator=(const class protocols::enzdes::DetectProteinLigandInterfaceOperationCreator &) –> class protocols::enzdes::DetectProteinLigandInterfaceOperationCreator &

create_task_operation(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterfaceOperationCreator) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::enzdes::DetectProteinLigandInterfaceOperationCreator::create_task_operation() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

keyname(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterfaceOperationCreator) → str¶: C++: protocols::enzdes::DetectProteinLigandInterfaceOperationCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.enzdes.DetectProteinLigandInterfaceOperationCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::DetectProteinLigandInterfaceOperationCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

skip_citation_info_in_schema(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperationCreator) → bool¶

Indicate whether we skip adding citation information to the XML schema.

False for any real task operation. True only for dummy task operations created for unit tests.

C++: core::pack::task::operation::TaskOperationCreator::skip_citation_info_in_schema() const –> bool

class pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilter¶

Bases: Filter

apply(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::enzdes::DiffAtomSasaFilter::apply(const class core::pose::Pose &) const –> bool

static class_name() → str¶: C++: protocols::enzdes::DiffAtomSasaFilter::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.DiffAtomSasaFilter) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::enzdes::DiffAtomSasaFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::enzdes::DiffAtomSasaFilter::compute(const class core::pose::Pose &) const –> bool

fresh_instance(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilter) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::enzdes::DiffAtomSasaFilter::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.DiffAtomSasaFilter) → str¶: C++: protocols::enzdes::DiffAtomSasaFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::enzdes::DiffAtomSasaFilter::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by filters wishing to provide citation information.

C++: protocols::filters::Filter::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::DiffAtomSasaFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilter, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::enzdes::DiffAtomSasaFilter::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::enzdes::DiffAtomSasaFilter::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 std::string &) –> void

class pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilterCreator¶

Bases: FilterCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilterCreator, : pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilterCreator) → pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilterCreator¶: C++: protocols::enzdes::DiffAtomSasaFilterCreator::operator=(const class protocols::enzdes::DiffAtomSasaFilterCreator &) –> class protocols::enzdes::DiffAtomSasaFilterCreator &

create_filter(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilterCreator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::enzdes::DiffAtomSasaFilterCreator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilterCreator) → str¶: C++: protocols::enzdes::DiffAtomSasaFilterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.enzdes.DiffAtomSasaFilterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::DiffAtomSasaFilterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.enzdes.DiversifyStoredRBConfs¶

Bases: 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¶

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>

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

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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¶

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

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) const –> void

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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::enzdes::EnzRepackMinimize::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, : pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize¶: C++: protocols::enzdes::EnzRepackMinimize::operator=(const class protocols::enzdes::EnzRepackMinimize &) –> class protocols::enzdes::EnzRepackMinimize &

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

clear_info is called by jd2 before calling apply

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

clone(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::enzdes::EnzRepackMinimize::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>

create_ptask(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.PackerTask¶: C++: protocols::enzdes::EnzRepackMinimize::create_ptask(class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::PackerTask>

ensure_scofx_cstfication(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

turns on constraint score terms in case the pose: has an enzdes cst cache

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

fresh_instance(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::enzdes::EnzRepackMinimize::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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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_design(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → bool¶: C++: protocols::enzdes::EnzRepackMinimize::get_design() const –> bool

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¶

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

get_min_bb(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → bool¶: C++: protocols::enzdes::EnzRepackMinimize::get_min_bb() const –> bool

get_min_lig(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → bool¶: C++: protocols::enzdes::EnzRepackMinimize::get_min_lig() const –> bool

get_min_rb(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → bool¶: C++: protocols::enzdes::EnzRepackMinimize::get_min_rb() const –> bool

get_min_sc(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → bool¶: C++: protocols::enzdes::EnzRepackMinimize::get_min_sc() const –> bool

get_name(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → str¶: C++: protocols::enzdes::EnzRepackMinimize::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_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

minimize_in_stages(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, cstopt: bool, min_sc: bool, min_rb: bool, min_lig: bool) → None¶: C++: protocols::enzdes::EnzRepackMinimize::minimize_in_stages(class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, const bool &, const bool &, const bool &, const bool &) –> void

static mover_name() → str¶: C++: protocols::enzdes::EnzRepackMinimize::mover_name() –> std::string

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::enzdes::EnzRepackMinimize::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::EnzRepackMinimize::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

rb_min_jumps(*args, **kwargs)¶

Overloaded function.

rb_min_jumps(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::enzdes::EnzRepackMinimize::rb_min_jumps() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

rb_min_jumps(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, : pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::enzdes::EnzRepackMinimize::rb_min_jumps(const class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

static 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

scorefxn_minimize(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::enzdes::EnzRepackMinimize::scorefxn_minimize() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

scorefxn_repack(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::enzdes::EnzRepackMinimize::scorefxn_repack() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> void

set_design(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, des: bool) → None¶: C++: protocols::enzdes::EnzRepackMinimize::set_design(const bool) –> void

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

setter for poses contained for rms

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

set_min_bb(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, min_bb: bool) → None¶: C++: protocols::enzdes::EnzRepackMinimize::set_min_bb(const bool) –> void

set_min_lig(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, min_lig: bool) → None¶: C++: protocols::enzdes::EnzRepackMinimize::set_min_lig(const bool) –> void

set_min_rb(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, min_rb: bool) → None¶: C++: protocols::enzdes::EnzRepackMinimize::set_min_rb(const bool) –> void

set_min_sc(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, min_sc: bool) → None¶: C++: protocols::enzdes::EnzRepackMinimize::set_min_sc(const 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_scorefxn_minimize(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::enzdes::EnzRepackMinimize::set_scorefxn_minimize(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_scorefxn_repack(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::enzdes::EnzRepackMinimize::set_scorefxn_repack(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) const –> void

task_factory(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimize, p: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶: C++: protocols::enzdes::EnzRepackMinimize::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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimizeCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimizeCreator, : pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimizeCreator) → pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimizeCreator¶: C++: protocols::enzdes::EnzRepackMinimizeCreator::operator=(const class protocols::enzdes::EnzRepackMinimizeCreator &) –> class protocols::enzdes::EnzRepackMinimizeCreator &

create_mover(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimizeCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::enzdes::EnzRepackMinimizeCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimizeCreator) → str¶: C++: protocols::enzdes::EnzRepackMinimizeCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.enzdes.EnzRepackMinimizeCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::EnzRepackMinimizeCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.enzdes.EnzScoreFilter¶

Bases: Filter

apply(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::enzdes::EnzScoreFilter::apply(const class core::pose::Pose &) const –> bool

static class_name() → str¶: C++: protocols::enzdes::EnzScoreFilter::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.EnzScoreFilter) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::enzdes::EnzScoreFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::enzdes::EnzScoreFilter::compute(const class core::pose::Pose &) const –> double

static default_value_for_cstid() → str¶: C++: protocols::enzdes::EnzScoreFilter::default_value_for_cstid() –> std::string

static default_value_for_is_cstE() → bool¶: C++: protocols::enzdes::EnzScoreFilter::default_value_for_is_cstE() –> bool

static default_value_for_resnum() → str¶: C++: protocols::enzdes::EnzScoreFilter::default_value_for_resnum() –> std::string

static default_value_for_score_type() → str¶: C++: protocols::enzdes::EnzScoreFilter::default_value_for_score_type() –> std::string

static default_value_for_threshold() → float¶: C++: protocols::enzdes::EnzScoreFilter::default_value_for_threshold() –> double

static default_value_for_whole_pose() → bool¶: C++: protocols::enzdes::EnzScoreFilter::default_value_for_whole_pose() –> bool

fresh_instance(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilter) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::enzdes::EnzScoreFilter::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.EnzScoreFilter) → str¶: C++: protocols::enzdes::EnzScoreFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::enzdes::EnzScoreFilter::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by filters wishing to provide citation information.

C++: protocols::filters::Filter::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::EnzScoreFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilter, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::enzdes::EnzScoreFilter::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::enzdes::EnzScoreFilter::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 std::string &) –> void

class pyrosetta.rosetta.protocols.enzdes.EnzScoreFilterCreator¶

Bases: FilterCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilterCreator, : pyrosetta.rosetta.protocols.enzdes.EnzScoreFilterCreator) → pyrosetta.rosetta.protocols.enzdes.EnzScoreFilterCreator¶: C++: protocols::enzdes::EnzScoreFilterCreator::operator=(const class protocols::enzdes::EnzScoreFilterCreator &) –> class protocols::enzdes::EnzScoreFilterCreator &

create_filter(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilterCreator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::enzdes::EnzScoreFilterCreator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilterCreator) → str¶: C++: protocols::enzdes::EnzScoreFilterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.enzdes.EnzScoreFilterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::EnzScoreFilterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol¶

Bases: LigandBaseProtocol

add_pregenerated_enzdes_constraints(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::add_pregenerated_enzdes_constraints(class core::pose::Pose &) const –> void

apply(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, : pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) → pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol¶: C++: protocols::enzdes::EnzdesBaseProtocol::operator=(const class protocols::enzdes::EnzdesBaseProtocol &) –> class protocols::enzdes::EnzdesBaseProtocol &

catalytic_res(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::enzdes::EnzdesBaseProtocol::catalytic_res(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

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

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>

create_enzdes_movemap(*args, **kwargs)¶

Overloaded function.

create_enzdes_movemap(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) -> pyrosetta.rosetta.core.kinematics.MoveMap
create_enzdes_movemap(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, min_all_jumps: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::enzdes::EnzdesBaseProtocol::create_enzdes_movemap(class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, bool) –> class std::shared_ptr<class core::kinematics::MoveMap>

create_enzdes_pack_task(*args, **kwargs)¶

Overloaded function.

create_enzdes_pack_task(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.PackerTask
create_enzdes_pack_task(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, design: bool) -> pyrosetta.rosetta.core.pack.task.PackerTask

C++: protocols::enzdes::EnzdesBaseProtocol::create_enzdes_pack_task(class core::pose::Pose &, bool) –> class std::shared_ptr<class core::pack::task::PackerTask>

cst_minimize(*args, **kwargs)¶

Overloaded function.

cst_minimize(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) -> None
cst_minimize(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, cst_opt: bool) -> None

C++: protocols::enzdes::EnzdesBaseProtocol::cst_minimize(class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, bool) –> void

design_targets(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.set_unsigned_long_t¶: C++: protocols::enzdes::EnzdesBaseProtocol::design_targets(const class core::pose::Pose &) const –> const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &

design_targets_score(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::enzdes::EnzdesBaseProtocol::design_targets_score(const class core::pose::Pose &) const –> double

enzdes_pack(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, cycles: int, minimize_after_packing: bool, pack_unconstrained: bool, favor_native: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::enzdes_pack(class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, class std::shared_ptr<const class core::scoring::ScoreFunction>, unsigned long, bool, bool, bool) –> 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>

generate_explicit_ligand_rotamer_poses(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, orig_pose: pyrosetta.rosetta.core.pose.Pose, ligrot_poses: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t, scofx: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::generate_explicit_ligand_rotamer_poses(const class core::pose::Pose &, class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > > &, class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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¶

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

static get_ligand_id(*args, **kwargs)¶

Overloaded function.

get_ligand_id(pose: pyrosetta.rosetta.core.pose.Pose) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &) –> unsigned long

get_ligand_id(pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &, unsigned long) –> unsigned long

static get_ligand_jump_id(pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_jump_id(const class core::pose::Pose &) –> unsigned long

get_name(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) → str¶: C++: protocols::enzdes::EnzdesBaseProtocol::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_non_bb_clashing_rotamers(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int, scofx: pyrosetta.rosetta.core.scoring.ScoreFunction, accepted_rotamers: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_non_bb_clashing_rotamers(const class core::pose::Pose &, unsigned long, class std::shared_ptr<const class core::scoring::ScoreFunction>, 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

get_scorefxn(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

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_t¶

non-const accessor

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

is_catalytic_position(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → bool¶: C++: protocols::enzdes::EnzdesBaseProtocol::is_catalytic_position(const class core::pose::Pose &, const unsigned long) const –> bool

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

rb_min_jumps(*args, **kwargs)¶

Overloaded function.

rb_min_jumps(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::enzdes::EnzdesBaseProtocol::rb_min_jumps() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

rb_min_jumps(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, : pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::enzdes::EnzdesBaseProtocol::rb_min_jumps(const class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

reduced_scorefxn(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::enzdes::EnzdesBaseProtocol::reduced_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

static register_options() → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::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

remap_resid(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, smap: pyrosetta.rosetta.core.id.SequenceMapping) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::remap_resid(const class core::pose::Pose &, const class core::id::SequenceMapping &) –> void

remove_enzdes_constraints(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, keep_covalent: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::remove_enzdes_constraints(class core::pose::Pose &, bool) const –> void

reorder_foldtree_around_mobile_regions(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int, mobile_bb: pyrosetta.rosetta.utility.vector1_bool, lig_id: int) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::reorder_foldtree_around_mobile_regions(class core::pose::Pose &, const unsigned long &, const class utility::vector1<bool, class std::allocator<bool> > &, const unsigned long &) const –> void

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

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

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

restrain_protein_Calphas(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, is_restrained: pyrosetta.rosetta.utility.vector1_bool, restr_func: pyrosetta.rosetta.core.scoring.func.Func) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::restrain_protein_Calphas(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class std::shared_ptr<class core::scoring::func::Func>) –> void

restype_set(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) → pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t¶: C++: protocols::enzdes::EnzdesBaseProtocol::restype_set() const –> class std::weak_ptr<const class core::chemical::ResidueTypeSet>

set_all_jumps_minimizable(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, setting: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::set_all_jumps_minimizable(const bool &) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> void

set_fix_cataa(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, setting: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::set_fix_cataa(const bool &) –> void

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

setter for poses contained for rms

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

set_minimize_options(*args, **kwargs)¶

Overloaded function.

set_minimize_options(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, min_sc: bool, min_bb: bool, min_rb: bool, min_lig: bool) -> None
set_minimize_options(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, min_sc: bool, min_bb: bool, min_rb: bool, min_lig: bool, backrub: bool) -> None

C++: protocols::enzdes::EnzdesBaseProtocol::set_minimize_options(const bool &, const bool &, const bool &, const bool &, 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_scorefxn(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::set_scorefxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

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

Set the ‘type’ string

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

setup_bbmin_ft_and_csts(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, allow_move_bb: pyrosetta.rosetta.utility.vector1_bool, jump_id: int) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::setup_bbmin_ft_and_csts(class core::pose::Pose &, class utility::vector1<bool, class std::allocator<bool> >, unsigned long) –> void

setup_sequence_recovery_cache(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::setup_sequence_recovery_cache(class core::pose::Pose &, const class core::pack::task::PackerTask &) const –> void

shared_from_this(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol¶: C++: protocols::ligand_docking::LigandBaseProtocol::shared_from_this() –> class std::shared_ptr<class protocols::ligand_docking::LigandBaseProtocol>

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.enzdes.EnzdesConstraintReporter¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzdesConstraintReporter, : pyrosetta.rosetta.protocols.enzdes.EnzdesConstraintReporter) → pyrosetta.rosetta.protocols.enzdes.EnzdesConstraintReporter¶: C++: protocols::enzdes::EnzdesConstraintReporter::operator=(const class protocols::enzdes::EnzdesConstraintReporter &) –> class protocols::enzdes::EnzdesConstraintReporter &

constrained_lig_atoms(self: pyrosetta.rosetta.protocols.enzdes.EnzdesConstraintReporter) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

Read access to the set of atoms that participate in distance constraints: to ligand atoms.

C++: protocols::enzdes::EnzdesConstraintReporter::constrained_lig_atoms() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

constrained_nonligand_atoms(self: pyrosetta.rosetta.protocols.enzdes.EnzdesConstraintReporter) → pyrosetta.rosetta.utility.vector1_core_id_AtomID¶: C++: protocols::enzdes::EnzdesConstraintReporter::constrained_nonligand_atoms() const –> const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

find_constraints_to_ligand(self: pyrosetta.rosetta.protocols.enzdes.EnzdesConstraintReporter, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Recurse through all the constraints in the pose to the ligand,: through all the constraint-container constraints (e.g. Ambiguous constraints and multi-constraints) to find all the atoms that participate in various constraints to ligand atoms in the input Pose.

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

ligand_resno(*args, **kwargs)¶

Overloaded function.

ligand_resno(self: pyrosetta.rosetta.protocols.enzdes.EnzdesConstraintReporter, res_no: int) -> None

Set the (one) ligand residue index

C++: protocols::enzdes::EnzdesConstraintReporter::ligand_resno(unsigned long) –> void

ligand_resno(self: pyrosetta.rosetta.protocols.enzdes.EnzdesConstraintReporter) -> int

Get the (one) ligand residue index

C++: protocols::enzdes::EnzdesConstraintReporter::ligand_resno() const –> unsigned long

class pyrosetta.rosetta.protocols.enzdes.EnzdesFixBBProtocol¶

Bases: EnzdesBaseProtocol

add_pregenerated_enzdes_constraints(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::add_pregenerated_enzdes_constraints(class core::pose::Pose &) const –> void

apply(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFixBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::enzdes::EnzdesFixBBProtocol::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFixBBProtocol, : pyrosetta.rosetta.protocols.enzdes.EnzdesFixBBProtocol) → pyrosetta.rosetta.protocols.enzdes.EnzdesFixBBProtocol¶: C++: protocols::enzdes::EnzdesFixBBProtocol::operator=(const class protocols::enzdes::EnzdesFixBBProtocol &) –> class protocols::enzdes::EnzdesFixBBProtocol &

catalytic_res(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::enzdes::EnzdesBaseProtocol::catalytic_res(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

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

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>

create_enzdes_movemap(*args, **kwargs)¶

Overloaded function.

create_enzdes_movemap(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) -> pyrosetta.rosetta.core.kinematics.MoveMap
create_enzdes_movemap(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, min_all_jumps: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

create_enzdes_pack_task(*args, **kwargs)¶

Overloaded function.

create_enzdes_pack_task(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.PackerTask
create_enzdes_pack_task(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, design: bool) -> pyrosetta.rosetta.core.pack.task.PackerTask

C++: protocols::enzdes::EnzdesBaseProtocol::create_enzdes_pack_task(class core::pose::Pose &, bool) –> class std::shared_ptr<class core::pack::task::PackerTask>

cst_minimize(*args, **kwargs)¶

Overloaded function.

cst_minimize(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) -> None
cst_minimize(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, cst_opt: bool) -> None

C++: protocols::enzdes::EnzdesBaseProtocol::cst_minimize(class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, bool) –> void

design_targets(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.set_unsigned_long_t¶: C++: protocols::enzdes::EnzdesBaseProtocol::design_targets(const class core::pose::Pose &) const –> const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &

design_targets_score(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::enzdes::EnzdesBaseProtocol::design_targets_score(const class core::pose::Pose &) const –> double

enzdes_pack(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, cycles: int, minimize_after_packing: bool, pack_unconstrained: bool, favor_native: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::enzdes_pack(class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, class std::shared_ptr<const class core::scoring::ScoreFunction>, unsigned long, bool, bool, bool) –> 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>

generate_explicit_ligand_rotamer_poses(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, orig_pose: pyrosetta.rosetta.core.pose.Pose, ligrot_poses: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t, scofx: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::generate_explicit_ligand_rotamer_poses(const class core::pose::Pose &, class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > > &, class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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¶

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

static get_ligand_id(*args, **kwargs)¶

Overloaded function.

get_ligand_id(pose: pyrosetta.rosetta.core.pose.Pose) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &) –> unsigned long

get_ligand_id(pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &, unsigned long) –> unsigned long

static get_ligand_jump_id(pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_jump_id(const class core::pose::Pose &) –> unsigned long

get_name(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFixBBProtocol) → str¶: C++: protocols::enzdes::EnzdesFixBBProtocol::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_non_bb_clashing_rotamers(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int, scofx: pyrosetta.rosetta.core.scoring.ScoreFunction, accepted_rotamers: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_non_bb_clashing_rotamers(const class core::pose::Pose &, unsigned long, class std::shared_ptr<const class core::scoring::ScoreFunction>, 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

get_scorefxn(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

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_t¶

non-const accessor

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

is_catalytic_position(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → bool¶: C++: protocols::enzdes::EnzdesBaseProtocol::is_catalytic_position(const class core::pose::Pose &, const unsigned long) const –> bool

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

rb_min_jumps(*args, **kwargs)¶

Overloaded function.

rb_min_jumps(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::enzdes::EnzdesBaseProtocol::rb_min_jumps() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

rb_min_jumps(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, : pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::enzdes::EnzdesBaseProtocol::rb_min_jumps(const class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

reduced_scorefxn(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::enzdes::EnzdesBaseProtocol::reduced_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

static register_options() → None¶: C++: protocols::enzdes::EnzdesFixBBProtocol::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

remap_resid(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, smap: pyrosetta.rosetta.core.id.SequenceMapping) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::remap_resid(const class core::pose::Pose &, const class core::id::SequenceMapping &) –> void

remove_enzdes_constraints(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, keep_covalent: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::remove_enzdes_constraints(class core::pose::Pose &, bool) const –> void

reorder_foldtree_around_mobile_regions(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int, mobile_bb: pyrosetta.rosetta.utility.vector1_bool, lig_id: int) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::reorder_foldtree_around_mobile_regions(class core::pose::Pose &, const unsigned long &, const class utility::vector1<bool, class std::allocator<bool> > &, const unsigned long &) const –> void

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

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

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

restrain_protein_Calphas(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, is_restrained: pyrosetta.rosetta.utility.vector1_bool, restr_func: pyrosetta.rosetta.core.scoring.func.Func) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::restrain_protein_Calphas(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class std::shared_ptr<class core::scoring::func::Func>) –> void

restype_set(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) → pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t¶: C++: protocols::enzdes::EnzdesBaseProtocol::restype_set() const –> class std::weak_ptr<const class core::chemical::ResidueTypeSet>

set_all_jumps_minimizable(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, setting: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::set_all_jumps_minimizable(const bool &) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> void

set_fix_cataa(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, setting: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::set_fix_cataa(const bool &) –> void

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

setter for poses contained for rms

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

set_minimize_options(*args, **kwargs)¶

Overloaded function.

set_minimize_options(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, min_sc: bool, min_bb: bool, min_rb: bool, min_lig: bool) -> None
set_minimize_options(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, min_sc: bool, min_bb: bool, min_rb: bool, min_lig: bool, backrub: bool) -> None

C++: protocols::enzdes::EnzdesBaseProtocol::set_minimize_options(const bool &, const bool &, const bool &, const bool &, 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_scorefxn(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::set_scorefxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

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

Set the ‘type’ string

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

setup_bbmin_ft_and_csts(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, allow_move_bb: pyrosetta.rosetta.utility.vector1_bool, jump_id: int) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::setup_bbmin_ft_and_csts(class core::pose::Pose &, class utility::vector1<bool, class std::allocator<bool> >, unsigned long) –> void

setup_sequence_recovery_cache(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::setup_sequence_recovery_cache(class core::pose::Pose &, const class core::pack::task::PackerTask &) const –> void

shared_from_this(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol¶: C++: protocols::ligand_docking::LigandBaseProtocol::shared_from_this() –> class std::shared_ptr<class protocols::ligand_docking::LigandBaseProtocol>

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol¶

Bases: EnzdesBaseProtocol

add_flexible_region(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, start: int, end: int, pose: pyrosetta.rosetta.core.pose.Pose, clear_existing: bool) → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::add_flexible_region(unsigned long, unsigned long, const class core::pose::Pose &, bool) –> void

add_pregenerated_enzdes_constraints(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::add_pregenerated_enzdes_constraints(class core::pose::Pose &) const –> void

apply(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, : pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol) → pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::operator=(const class protocols::enzdes::EnzdesFlexBBProtocol &) –> class protocols::enzdes::EnzdesFlexBBProtocol &

catalytic_res(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::enzdes::EnzdesBaseProtocol::catalytic_res(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

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

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>

create_enzdes_movemap(*args, **kwargs)¶

Overloaded function.

create_enzdes_movemap(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) -> pyrosetta.rosetta.core.kinematics.MoveMap
create_enzdes_movemap(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, min_all_jumps: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

create_enzdes_pack_task(*args, **kwargs)¶

Overloaded function.

create_enzdes_pack_task(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.PackerTask
create_enzdes_pack_task(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, design: bool) -> pyrosetta.rosetta.core.pack.task.PackerTask

C++: protocols::enzdes::EnzdesBaseProtocol::create_enzdes_pack_task(class core::pose::Pose &, bool) –> class std::shared_ptr<class core::pack::task::PackerTask>

cst_minimize(*args, **kwargs)¶

Overloaded function.

cst_minimize(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) -> None
cst_minimize(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, cst_opt: bool) -> None

C++: protocols::enzdes::EnzdesBaseProtocol::cst_minimize(class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, bool) –> void

design_targets(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.set_unsigned_long_t¶: C++: protocols::enzdes::EnzdesBaseProtocol::design_targets(const class core::pose::Pose &) const –> const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &

design_targets_score(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::enzdes::EnzdesBaseProtocol::design_targets_score(const class core::pose::Pose &) const –> double

determine_flexible_regions(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::determine_flexible_regions(const class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>) –> void

enz_flexible_region(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, region: int) → protocols::enzdes::EnzdesFlexibleRegion¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::enz_flexible_region(unsigned long) const –> class std::shared_ptr<const class protocols::enzdes::EnzdesFlexibleRegion>

enz_loops_file(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol) → protocols::toolbox::match_enzdes_util::EnzdesLoopsFile¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::enz_loops_file() const –> class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::EnzdesLoopsFile>

enzdes_pack(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pack.task.PackerTask, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, cycles: int, minimize_after_packing: bool, pack_unconstrained: bool, favor_native: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::enzdes_pack(class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, class std::shared_ptr<const class core::scoring::ScoreFunction>, unsigned long, bool, bool, bool) –> 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>

generate_alc_ensemble_for_region(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose, region: int) → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::generate_alc_ensemble_for_region(class core::pose::Pose &, unsigned long) –> void

generate_backrub_ensemble_for_region(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose, region: int) → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::generate_backrub_ensemble_for_region(class core::pose::Pose &, unsigned long) –> void

generate_ensemble_for_region(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose, region: int) → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::generate_ensemble_for_region(class core::pose::Pose &, unsigned long) –> void

generate_explicit_ligand_rotamer_poses(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, orig_pose: pyrosetta.rosetta.core.pose.Pose, ligrot_poses: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t, scofx: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::generate_explicit_ligand_rotamer_poses(const class core::pose::Pose &, class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > > &, class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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¶

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

static get_ligand_id(*args, **kwargs)¶

Overloaded function.

get_ligand_id(pose: pyrosetta.rosetta.core.pose.Pose) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &) –> unsigned long

get_ligand_id(pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int) -> int

C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_id(const class core::pose::Pose &, unsigned long) –> unsigned long

static get_ligand_jump_id(pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_ligand_jump_id(const class core::pose::Pose &) –> unsigned long

get_name(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol) → str¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::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_non_bb_clashing_rotamers(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int, scofx: pyrosetta.rosetta.core.scoring.ScoreFunction, accepted_rotamers: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_conformation_Residue_t) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_non_bb_clashing_rotamers(const class core::pose::Pose &, unsigned long, class std::shared_ptr<const class core::scoring::ScoreFunction>, 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

get_scorefxn(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::ligand_docking::LigandBaseProtocol::get_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

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_tenA_neighbor_residues(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose, residue_positions: pyrosetta.rosetta.utility.vector1_bool) → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::get_tenA_neighbor_residues(const class core::pose::Pose &, class utility::vector1<bool, class std::allocator<bool> > &) const –> void

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_t¶

non-const accessor

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

is_catalytic_position(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → bool¶: C++: protocols::enzdes::EnzdesBaseProtocol::is_catalytic_position(const class core::pose::Pose &, const unsigned long) const –> bool

is_flexible(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, seqpos: int) → bool¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::is_flexible(unsigned long) const –> bool

is_remodelable(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, seqpos: int) → bool¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::is_remodelable(unsigned long) const –> bool

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

minimize_flexible_region(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose, region: int, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, chi_to_move: pyrosetta.rosetta.std.set_unsigned_long_t, including_CA_angles: bool, min_tolerance: float) → bool¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::minimize_flexible_region(class core::pose::Pose &, unsigned long, class std::shared_ptr<const class core::scoring::ScoreFunction>, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, const bool, double) –> bool

modified_task(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose, orig_task: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.pack.task.PackerTask¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::modified_task(const class core::pose::Pose &, const class core::pack::task::PackerTask &) –> class std::shared_ptr<class core::pack::task::PackerTask>

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

rb_min_jumps(*args, **kwargs)¶

Overloaded function.

rb_min_jumps(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::enzdes::EnzdesBaseProtocol::rb_min_jumps() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

rb_min_jumps(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, : pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::enzdes::EnzdesBaseProtocol::rb_min_jumps(const class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

reduced_scorefxn(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) → pyrosetta.rosetta.core.scoring.ScoreFunction¶: C++: protocols::enzdes::EnzdesBaseProtocol::reduced_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

static register_options() → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::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

remap_resid(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose, smap: pyrosetta.rosetta.core.id.SequenceMapping) → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::remap_resid(const class core::pose::Pose &, const class core::id::SequenceMapping &) –> void

remove_enzdes_constraints(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, keep_covalent: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::remove_enzdes_constraints(class core::pose::Pose &, bool) const –> void

reorder_foldtree_around_mobile_regions(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, jump_id: int, mobile_bb: pyrosetta.rosetta.utility.vector1_bool, lig_id: int) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::reorder_foldtree_around_mobile_regions(class core::pose::Pose &, const unsigned long &, const class utility::vector1<bool, class std::allocator<bool> > &, const unsigned long &) const –> void

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

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

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

restrain_protein_Calphas(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, is_restrained: pyrosetta.rosetta.utility.vector1_bool, restr_func: pyrosetta.rosetta.core.scoring.func.Func) → None¶: C++: protocols::ligand_docking::LigandBaseProtocol::restrain_protein_Calphas(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class std::shared_ptr<class core::scoring::func::Func>) –> void

restype_set(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol) → pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t¶: C++: protocols::enzdes::EnzdesBaseProtocol::restype_set() const –> class std::weak_ptr<const class core::chemical::ResidueTypeSet>

set_all_jumps_minimizable(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, setting: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::set_all_jumps_minimizable(const bool &) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> void

set_fix_cataa(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, setting: bool) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::set_fix_cataa(const bool &) –> void

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

setter for poses contained for rms

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

set_minimize_options(*args, **kwargs)¶

Overloaded function.

set_minimize_options(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, min_sc: bool, min_bb: bool, min_rb: bool, min_lig: bool) -> None
set_minimize_options(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, min_sc: bool, min_bb: bool, min_rb: bool, min_lig: bool, backrub: bool) -> None

C++: protocols::enzdes::EnzdesBaseProtocol::set_minimize_options(const bool &, const bool &, const bool &, const bool &, 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_scorefxn(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::set_scorefxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

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

Set the ‘type’ string

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

setup_bbmin_ft_and_csts(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, allow_move_bb: pyrosetta.rosetta.utility.vector1_bool, jump_id: int) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::setup_bbmin_ft_and_csts(class core::pose::Pose &, class utility::vector1<bool, class std::allocator<bool> >, unsigned long) –> void

setup_sequence_recovery_cache(self: pyrosetta.rosetta.protocols.enzdes.EnzdesBaseProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::enzdes::EnzdesBaseProtocol::setup_sequence_recovery_cache(class core::pose::Pose &, const class core::pack::task::PackerTask &) const –> void

shared_from_this(self: pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol) → pyrosetta.rosetta.protocols.ligand_docking.LigandBaseProtocol¶: C++: protocols::ligand_docking::LigandBaseProtocol::shared_from_this() –> class std::shared_ptr<class protocols::ligand_docking::LigandBaseProtocol>

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) const –> void

test_flexbb_rotamer_sets(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexBBProtocol, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::enzdes::EnzdesFlexBBProtocol::test_flexbb_rotamer_sets(const class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>) –> 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion¶

Bases: Frame

static _static_type_name() → str¶: C++: core::fragment::Frame::_static_type_name() –> std::string

add_fragment(*args, **kwargs)¶

Overloaded function.

add_fragment(self: pyrosetta.rosetta.core.fragment.Frame, new_frag: core::fragment::FragData) -> int

add a fragment .. return new frag_nr

C++: core::fragment::Frame::add_fragment(class std::shared_ptr<const class core::fragment::FragData>) –> unsigned long

add_fragment(self: pyrosetta.rosetta.core.fragment.Frame, new_frags: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_fragment_FragData_t) -> bool

add all fragments in list

C++: core::fragment::Frame::add_fragment(class utility::vector1<class std::shared_ptr<const class core::fragment::FragData>, class std::allocator<class std::shared_ptr<const class core::fragment::FragData> > >) –> bool

align(self: pyrosetta.rosetta.core.fragment.Frame, map: pyrosetta.rosetta.core.id.SequenceMapping) → bool¶

change frames residue numbers accoriding to map

C++: core::fragment::Frame::align(const class core::id::SequenceMapping &) –> bool

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap, frag_num: int, pose: pyrosetta.rosetta.core.pose.Pose) -> int

insert fragment frag_num into pose

C++: core::fragment::Frame::apply(const class core::kinematics::MoveMap &, unsigned long, class core::pose::Pose &) const –> unsigned long

apply(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, pose: pyrosetta.rosetta.core.pose.Pose) -> int

insert fragment frag_num into pose — ignore movemap

C++: core::fragment::Frame::apply(unsigned long, class core::pose::Pose &) const –> unsigned long

apply_ranked_fragment(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose, frag_rank: int) → None¶: C++: protocols::enzdes::EnzdesFlexibleRegion::apply_ranked_fragment(class core::pose::Pose &, unsigned long) –> void

apply_ss(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap, frag_num: int, ss: str) → int¶

change ss-string according to sec-struct info in fragments

C++: core::fragment::Frame::apply_ss(const class core::kinematics::MoveMap &, unsigned long, std::string &) const –> unsigned long

assemble_enzdes_fragdata(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.fragment.FragData¶: C++: protocols::enzdes::EnzdesFlexibleRegion::assemble_enzdes_fragdata(const class core::pose::Pose &) –> class std::shared_ptr<class core::fragment::FragData>

assign(self: pyrosetta.rosetta.core.fragment.Frame, : pyrosetta.rosetta.core.fragment.Frame) → pyrosetta.rosetta.core.fragment.Frame¶: C++: core::fragment::Frame::operator=(const class core::fragment::Frame &) –> class core::fragment::Frame &

cache(self: pyrosetta.rosetta.core.fragment.Frame, tag: str, new_cache: pyrosetta.rosetta.core.fragment.BaseCacheUnit) → pyrosetta.rosetta.core.fragment.BaseCacheUnit¶

return handle to cached data stored under “tag”: shouldn’t be called directly

C++: core::fragment::Frame::cache(std::string, const class std::shared_ptr<class core::fragment::BaseCacheUnit> &) const –> class core::fragment::BaseCacheUnit &

calculate_rotamer_set_design_targets_partition_sum(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, task: pyrosetta.rosetta.core.pack.task.PackerTask, threads_to_request: int) → float¶: C++: protocols::enzdes::EnzdesFlexibleRegion::calculate_rotamer_set_design_targets_partition_sum(const class core::pose::Pose &, class std::shared_ptr<const class core::scoring::ScoreFunction>, class std::shared_ptr<const class core::pack::task::PackerTask>, const unsigned long) const –> double

clear(self: pyrosetta.rosetta.core.fragment.Frame) → None¶

remove all valid fragments, a template fragment will be left over

C++: core::fragment::Frame::clear() –> void

clone(self: pyrosetta.rosetta.core.fragment.Frame) → pyrosetta.rosetta.core.fragment.Frame¶

clone method, new frame with same alignment position, fragments are not copied!

C++: core::fragment::Frame::clone() const –> class std::shared_ptr<class core::fragment::Frame>

clone_cache_data(self: pyrosetta.rosetta.core.fragment.Frame, source: pyrosetta.rosetta.core.fragment.Frame, sid: int, nid: int) → None¶

copies all entries in the Frame-Cache for fragment “sid” of Frame “source” to fragment “nid” of “this” frame

C++: core::fragment::Frame::clone_cache_data(const class core::fragment::Frame &, unsigned long, unsigned long) –> void

clone_with_frags(self: pyrosetta.rosetta.core.fragment.Frame) → pyrosetta.rosetta.core.fragment.Frame¶

clone method, new frame with same alignment position, fragments are not copied!

C++: core::fragment::Frame::clone_with_frags() const –> class std::shared_ptr<class core::fragment::Frame>

clone_with_template(self: pyrosetta.rosetta.core.fragment.Frame) → pyrosetta.rosetta.core.fragment.Frame¶

clone method, new frame with same alignment position, one fragments is copied as template ( valid() == false )

C++: core::fragment::Frame::clone_with_template() –> class std::shared_ptr<class core::fragment::Frame>

static compare_SizeRealPairs(first: Tuple[int, float], second: Tuple[int, float]) → bool¶: C++: protocols::enzdes::EnzdesFlexibleRegion::compare_SizeRealPairs(const struct std::pair<unsigned long, double> &, const struct std::pair<unsigned long, double> &) –> bool

contains_catalytic_res(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion) → bool¶: C++: protocols::enzdes::EnzdesFlexibleRegion::contains_catalytic_res() const –> bool

contains_seqpos(self: pyrosetta.rosetta.core.fragment.Frame, seqpos: int) → bool¶

whether this fragment contains a certain position

C++: core::fragment::Frame::contains_seqpos(unsigned long) const –> bool

declare_remodelable(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, min_length: int, max_length: int) → None¶: C++: protocols::enzdes::EnzdesFlexibleRegion::declare_remodelable(unsigned long, unsigned long) –> void

deltaE_best(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, frag_rank: int) → float¶: C++: protocols::enzdes::EnzdesFlexibleRegion::deltaE_best(const unsigned long) const –> double

end(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

last sequence position affected by this frame

C++: core::fragment::Frame::end() const –> unsigned long

enz_loop_info(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion) → protocols::toolbox::match_enzdes_util::EnzdesLoopInfo¶: C++: protocols::enzdes::EnzdesFlexibleRegion::enz_loop_info() const –> class std::shared_ptr<const class protocols::toolbox::match_enzdes_util::EnzdesLoopInfo>

examine_new_loopconf(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose, template_pose: pyrosetta.rosetta.core.pose.Pose, compare_poses: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t, rmsd_to_native: pyrosetta.rosetta.utility.vector1_double) → bool¶: C++: protocols::enzdes::EnzdesFlexibleRegion::examine_new_loopconf(const class core::pose::Pose &, class core::pose::Pose &, class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > > &, class utility::vector1<double, class std::allocator<double> > &) –> bool

extract_lig_designability_score(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, backgroundE: float) → float¶: C++: protocols::enzdes::EnzdesFlexibleRegion::extract_lig_designability_score(const class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>, double &) –> double

frag_id(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int) → int¶

a unique id for every fragment in the list.: his is silly, but would enable later on to avoid cache_clearence on deletion of FragData entries in this case, we would require that the ID of a certain fragment never changes, even if the position in FragList changes

C++: core::fragment::Frame::frag_id(unsigned long) const –> unsigned long

fragment(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int) → core::fragment::FragData¶

accesors for underlying FragData

C++: core::fragment::Frame::fragment(unsigned long) const –> const class core::fragment::FragData &

fragment_as_pose(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int, pose: pyrosetta.rosetta.core.pose.Pose, restype_set: pyrosetta.rosetta.std.weak_ptr_const_core_chemical_ResidueTypeSet_t) → None¶

returns a (small) pose with fragment ( continous from seqpos 1 … nr_res_affected() )

C++: core::fragment::Frame::fragment_as_pose(unsigned long, class core::pose::Pose &, class std::weak_ptr<const class core::chemical::ResidueTypeSet>) const –> void

fragment_ptr(self: pyrosetta.rosetta.core.fragment.Frame, frag_num: int) → core::fragment::FragData¶

accessor for underlying FragData as owning ptr

C++: core::fragment::Frame::fragment_ptr(unsigned long) const –> class std::shared_ptr<const class core::fragment::FragData>

generate_sub_frame(*args, **kwargs)¶

Overloaded function.

generate_sub_frame(self: pyrosetta.rosetta.core.fragment.Frame, length: int) -> pyrosetta.rosetta.core.fragment.Frame
generate_sub_frame(self: pyrosetta.rosetta.core.fragment.Frame, length: int, start: int) -> pyrosetta.rosetta.core.fragment.Frame

generate_sub_frame of length from start ( internal numbers )

C++: core::fragment::Frame::generate_sub_frame(unsigned long, unsigned long) const –> class std::shared_ptr<class core::fragment::Frame>

get_10A_neighbors(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.set_unsigned_long_t¶: C++: protocols::enzdes::EnzdesFlexibleRegion::get_10A_neighbors(const class core::pose::Pose &) const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

get_region_mm_bend_score(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::enzdes::EnzdesFlexibleRegion::get_region_mm_bend_score(const class core::pose::Pose &) const –> double

get_region_total_score(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::enzdes::EnzdesFlexibleRegion::get_region_total_score(const class core::pose::Pose &) const –> double

hack_fillup_frag_designabilities(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion) → None¶: C++: protocols::enzdes::EnzdesFlexibleRegion::hack_fillup_frag_designabilities() –> void

index(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion) → int¶: C++: protocols::enzdes::EnzdesFlexibleRegion::index() const –> unsigned long

is_applicable(self: pyrosetta.rosetta.core.fragment.Frame, : core::kinematics::MoveMap) → int¶

is the Frame applicable to the pose with the given movemap?

C++: core::fragment::Frame::is_applicable(const class core::kinematics::MoveMap &) const –> unsigned long

is_continuous(self: pyrosetta.rosetta.core.fragment.Frame) → bool¶

true if frame is continuous (always true for base class)

C++: core::fragment::Frame::is_continuous() const –> bool

is_mergeable(self: pyrosetta.rosetta.core.fragment.Frame, other: pyrosetta.rosetta.core.fragment.Frame) → bool¶: C++: core::fragment::Frame::is_mergeable(const class core::fragment::Frame &) const –> bool

is_valid(self: pyrosetta.rosetta.core.fragment.Frame) → bool¶

a frame is considered valid if at least one fragment is contained and this fragment is also valid: (not an empty template fragment)

C++: core::fragment::Frame::is_valid() const –> bool

length(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

number of residues in this frame ( for continuous frames it is the same as end()-start() + 1 )

C++: core::fragment::Frame::length() const –> unsigned long

merge(self: pyrosetta.rosetta.core.fragment.Frame, other: pyrosetta.rosetta.core.fragment.Frame) → bool¶: C++: core::fragment::Frame::merge(const class core::fragment::Frame &) –> bool

minimize_region(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, chi_to_move: pyrosetta.rosetta.std.set_unsigned_long_t, including_CA_angles: bool, min_tolerance: float) → bool¶: C++: protocols::enzdes::EnzdesFlexibleRegion::minimize_region(class core::pose::Pose &, class std::shared_ptr<const class core::scoring::ScoreFunction>, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, const bool, double) –> bool

moves_residue(self: pyrosetta.rosetta.core.fragment.Frame, pos: int) → bool¶: C++: core::fragment::Frame::moves_residue(unsigned long) const –> bool

no_ranked_frags(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion) → int¶: C++: protocols::enzdes::EnzdesFlexibleRegion::no_ranked_frags() const –> unsigned long

nr_frags(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

number of fragments attached to this frame

C++: core::fragment::Frame::nr_frags() const –> unsigned long

nr_res_affected(self: pyrosetta.rosetta.core.fragment.Frame, mm: core::kinematics::MoveMap) → int¶

number of residues affected by this frame

C++: core::fragment::Frame::nr_res_affected(const class core::kinematics::MoveMap &) const –> unsigned long

positions(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::enzdes::EnzdesFlexibleRegion::positions() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

read(self: pyrosetta.rosetta.core.fragment.Frame, in: pyrosetta.rosetta.std.istream) → None¶: C++: core::fragment::Frame::read(std::istream &) –> void

remap_resid(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, pose: pyrosetta.rosetta.core.pose.Pose, smap: pyrosetta.rosetta.core.id.SequenceMapping) → bool¶: C++: protocols::enzdes::EnzdesFlexibleRegion::remap_resid(const class core::pose::Pose &, const class core::id::SequenceMapping &) –> bool

remodel_max_length(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion) → int¶: C++: protocols::enzdes::EnzdesFlexibleRegion::remodel_max_length() const –> unsigned long

remodel_min_length(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion) → int¶: C++: protocols::enzdes::EnzdesFlexibleRegion::remodel_min_length() const –> unsigned long

remodelable(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion) → bool¶: C++: protocols::enzdes::EnzdesFlexibleRegion::remodelable() const –> bool

scale_target_proximity_to_other_conformations(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, factor: float) → None¶: C++: protocols::enzdes::EnzdesFlexibleRegion::scale_target_proximity_to_other_conformations(double) –> void

scale_target_proximity_to_starting_conformation(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, factor: float) → None¶: C++: protocols::enzdes::EnzdesFlexibleRegion::scale_target_proximity_to_starting_conformation(double) –> void

seqpos(self: pyrosetta.rosetta.core.fragment.Frame, intra_pos: int) → int¶

translate intra-frame position into sequence position. (trivial for base-class)

C++: core::fragment::Frame::seqpos(unsigned long) const –> unsigned long

set_target_proximity_to_starting_conformation(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, proximity: float) → None¶: C++: protocols::enzdes::EnzdesFlexibleRegion::set_target_proximity_to_starting_conformation(double) –> void

shift_by(self: pyrosetta.rosetta.core.fragment.Frame, offset: int) → None¶

shift frame by offset relative to current start position ( change end accordingly )

C++: core::fragment::Frame::shift_by(int) –> void

shift_to(self: pyrosetta.rosetta.core.fragment.Frame, setting: int) → None¶

shift to new start position ( change end accordingly )

C++: core::fragment::Frame::shift_to(unsigned long) –> void

show(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::fragment::Frame::show(std::ostream &) const –> void

show_classic(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::fragment::Frame::show_classic(std::ostream &) const –> void

show_header(self: pyrosetta.rosetta.core.fragment.Frame, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::fragment::Frame::show_header(std::ostream &) const –> void

sort_ensemble_by_designability(self: pyrosetta.rosetta.protocols.enzdes.EnzdesFlexibleRegion, ref_pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::enzdes::EnzdesFlexibleRegion::sort_ensemble_by_designability(const class core::pose::Pose &, class std::shared_ptr<class core::scoring::ScoreFunction>, class std::shared_ptr<const class core::pack::task::PackerTask>) –> void

start(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

first seqpos of this frame

C++: core::fragment::Frame::start() const –> unsigned long

steal(self: pyrosetta.rosetta.core.fragment.Frame, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

obtain fragment from pose at frame position

C++: core::fragment::Frame::steal(const class core::pose::Pose &) –> bool

stop(self: pyrosetta.rosetta.core.fragment.Frame) → int¶

last sequence position affected by this frame

C++: core::fragment::Frame::stop() const –> unsigned long

type(self: pyrosetta.rosetta.core.fragment.Frame) → str¶

type() is specifying the output name of the Frame in FragmentIO (“FRAME”, “JUMPFRAME”, etc)

C++: core::fragment::Frame::type() const –> std::string

class pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputter¶

Bases: PDBJobInputter

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputter, : pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputter) → pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputter¶: C++: protocols::enzdes::EnzdesJobInputter::operator=(const class protocols::enzdes::EnzdesJobInputter &) –> class protocols::enzdes::EnzdesJobInputter &

fill_jobs(self: pyrosetta.rosetta.protocols.jd2.PDBJobInputter, jobs: protocols::jd2::JobsContainer) → None¶

this function determines what jobs exist from -s/-l

C++: protocols::jd2::PDBJobInputter::fill_jobs(class protocols::jd2::JobsContainer &) –> void

get_self_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputter¶

Get self owning pointers.

C++: protocols::jd2::JobInputter::get_self_ptr() –> class std::shared_ptr<class protocols::jd2::JobInputter>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → pyrosetta.rosetta.std.weak_ptr_protocols_jd2_JobInputter_t¶

Get self weak pointers.

C++: protocols::jd2::JobInputter::get_self_weak_ptr() –> class std::weak_ptr<class protocols::jd2::JobInputter>

input_source(self: pyrosetta.rosetta.protocols.jd2.PDBJobInputter) → pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum¶

Return the type of input source that the PDBJobInputter is currently: using.

Always PDB_FILE.

C++: protocols::jd2::PDBJobInputter::input_source() const –> enum protocols::jd2::JobInputterInputSource::Enum

static job_inputter_input_source_to_string(source: pyrosetta.rosetta.protocols.jd2.JobInputterInputSource.Enum) → str¶

call this with input_source() to get the input source of a: particular job inputter

C++: protocols::jd2::JobInputter::job_inputter_input_source_to_string(enum protocols::jd2::JobInputterInputSource::Enum) –> std::string

pose_from_job(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None¶

this function is responsible for filling the pose reference with the pose: indicated by the job. The Job object (within its InnerJob) contains a PoseCOP. This function needs to either fill the pose reference from the InnerJob or, on first demand of a pose from that InnerJob, instantiate the pose, hand off a COP to the InnerJob, and fill the reference. This implementation uses pose_from_pdb

C++: protocols::enzdes::EnzdesJobInputter::pose_from_job(class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) –> void

update_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter, jobs: protocols::jd2::JobsContainer) → None¶

This function is only called by certain JobInputters to update the jobs list after it has already been created.

An example case would be the LargeNstructJobInputter, which uses this function to load additional jobs after the first N have started to come back.

C++: protocols::jd2::JobInputter::update_jobs_list(class std::shared_ptr<class protocols::jd2::JobsContainer>) –> void

updates_jobs_list(self: pyrosetta.rosetta.protocols.jd2.JobInputter) → bool¶

Does this type of JobInputter update the jobs list?

False by default. Override this function in derived classes to make it true.

C++: protocols::jd2::JobInputter::updates_jobs_list() const –> bool

class pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputterCreator¶

Bases: JobInputterCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputterCreator, : pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputterCreator) → pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputterCreator¶: C++: protocols::enzdes::EnzdesJobInputterCreator::operator=(const class protocols::enzdes::EnzdesJobInputterCreator &) –> class protocols::enzdes::EnzdesJobInputterCreator &

create_JobInputter(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputterCreator) → pyrosetta.rosetta.protocols.jd2.JobInputter¶: C++: protocols::enzdes::EnzdesJobInputterCreator::create_JobInputter() const –> class std::shared_ptr<class protocols::jd2::JobInputter>

keyname(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobInputterCreator) → str¶: C++: protocols::enzdes::EnzdesJobInputterCreator::keyname() const –> std::string

class pyrosetta.rosetta.protocols.enzdes.EnzdesJobOutputter¶

Bases: 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 &, std::string, 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 std::string &) –> 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 std::string &) –> 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.

other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
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 std::string &, 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.EnzdesJobOutputterCreator¶

Bases: JobOutputterCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobOutputterCreator, : pyrosetta.rosetta.protocols.enzdes.EnzdesJobOutputterCreator) → pyrosetta.rosetta.protocols.enzdes.EnzdesJobOutputterCreator¶: C++: protocols::enzdes::EnzdesJobOutputterCreator::operator=(const class protocols::enzdes::EnzdesJobOutputterCreator &) –> class protocols::enzdes::EnzdesJobOutputterCreator &

create_JobOutputter(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobOutputterCreator) → pyrosetta.rosetta.protocols.jd2.JobOutputter¶: C++: protocols::enzdes::EnzdesJobOutputterCreator::create_JobOutputter() const –> class std::shared_ptr<class protocols::jd2::JobOutputter>

keyname(self: pyrosetta.rosetta.protocols.enzdes.EnzdesJobOutputterCreator) → str¶: C++: protocols::enzdes::EnzdesJobOutputterCreator::keyname() const –> std::string

class pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilter¶

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

static 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) → None¶: C++: protocols::enzdes::EnzdesScorefileFilter::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by filters wishing to provide citation information.

C++: protocols::filters::Filter::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: 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(std::ostream &, 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 std::string &) –> 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.EnzdesScorefileFilterCreator¶

Bases: FilterCreator

assign(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilterCreator, : pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilterCreator) → pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilterCreator¶: C++: protocols::enzdes::EnzdesScorefileFilterCreator::operator=(const class protocols::enzdes::EnzdesScorefileFilterCreator &) –> class protocols::enzdes::EnzdesScorefileFilterCreator &

create_filter(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilterCreator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::enzdes::EnzdesScorefileFilterCreator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilterCreator) → str¶: C++: protocols::enzdes::EnzdesScorefileFilterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.enzdes.EnzdesScorefileFilterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::enzdes::EnzdesScorefileFilterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.enzdes.GenerateStoredRBConfs¶

Bases: 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¶

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>

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

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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¶

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

static 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) → 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 &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) const –> void

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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.enzdes.LigBurialFilter¶

Bases: Filter

apply(self: pyrosetta.rosetta.protocols.enzdes.LigBurialFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::enzdes::LigBurialFilter::apply(const class core::pose::Pose &) const –> bool

static class_name() → str¶: C++: protocols::enzdes::LigBurialFilter::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.LigBurialFilter) →