cyclic_peptide¶

crosslinker

Bindings for protocols::cyclic_peptide namespace

class pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover¶

Bases: Mover

This mover is designed to be general and compatible with both homo- and hetero-polymers of the following type: peptides (not Gly or Pro), peptoids, glycine, proline, and N-methylated amino acids. The purtubations that are allowed for different combinations at the i and i+1 positions and compatible conformations are described in the table below.

i | i+1 | Action | Nickname |

|--------------+------------------------+--------------------------------------------------------------------------------------+-----------| | Peptoid, Gly | Peptoid, Pro, N-Methyl | phi_i negate, psi_i negate, omg_i flip by 180 | “Peptoid” | | Any(?) | Gly | psi_i 0<->(-30,180), phi_i+1 180<->(-90,+-60) | “Pre-Gly” | | Peptide | Peptide (not P) | if psi_i/phi_i+1 near -120/-60 or 120/60: psi_i negate, omg_i negate, phi_i+1 negate | “Peptide” |

allow_peptide_flips(*args, **kwargs)¶

Overloaded function.

allow_peptide_flips(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, af: bool) -> None

C++: protocols::cyclic_peptide::CrankshaftFlipMover::allow_peptide_flips(bool) –> void

allow_peptide_flips(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover) -> bool

C++: protocols::cyclic_peptide::CrankshaftFlipMover::allow_peptide_flips() –> bool

allow_peptoid_flips(*args, **kwargs)¶

Overloaded function.

allow_peptoid_flips(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, af: bool) -> None

Setters and Getters

C++: protocols::cyclic_peptide::CrankshaftFlipMover::allow_peptoid_flips(bool) –> void

allow_peptoid_flips(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover) -> bool

C++: protocols::cyclic_peptide::CrankshaftFlipMover::allow_peptoid_flips() –> bool

allow_pre_gly_flips(*args, **kwargs)¶

Overloaded function.

allow_pre_gly_flips(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, af: bool) -> None

C++: protocols::cyclic_peptide::CrankshaftFlipMover::allow_pre_gly_flips(bool) –> void

allow_pre_gly_flips(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover) -> bool

C++: protocols::cyclic_peptide::CrankshaftFlipMover::allow_pre_gly_flips() –> bool

angle_degrees_in_range(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, angle: float, target: float) → bool¶: C++: protocols::cyclic_peptide::CrankshaftFlipMover::angle_degrees_in_range(double, double) –> bool

apply(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Apply the mover

C++: protocols::cyclic_peptide::CrankshaftFlipMover::apply(class core::pose::Pose &) –> void

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

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

required in the context of the parser/scripting scheme

C++: protocols::cyclic_peptide::CrankshaftFlipMover::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.cyclic_peptide.CrankshaftFlipMover) → pyrosetta.rosetta.protocols.moves.Mover¶

required in the context of the parser/scripting scheme

C++: protocols::cyclic_peptide::CrankshaftFlipMover::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¶

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.cyclic_peptide.CrankshaftFlipMover) → str¶: C++: protocols::cyclic_peptide::CrankshaftFlipMover::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::cyclic_peptide::CrankshaftFlipMover::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

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

C++: protocols::cyclic_peptide::CrankshaftFlipMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, citations: pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Sets up the citation info

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::cyclic_peptide::CrankshaftFlipMover::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

selector(*args, **kwargs)¶

Overloaded function.

selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) -> None

C++: protocols::cyclic_peptide::CrankshaftFlipMover::selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover) -> pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

C++: protocols::cyclic_peptide::CrankshaftFlipMover::selector() –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

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.cyclic_peptide.CrankshaftFlipMover) -> None
show(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, output: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::cyclic_peptide::CrankshaftFlipMover::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

tolerance(*args, **kwargs)¶

Overloaded function.

tolerance(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover) -> float

C++: protocols::cyclic_peptide::CrankshaftFlipMover::tolerance() const –> double

tolerance(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, tolerance: float) -> None

C++: protocols::cyclic_peptide::CrankshaftFlipMover::tolerance(double) –> void

try_peptide_flip(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, pose: pyrosetta.rosetta.core.pose.Pose, res1_index: int, res2_index: int) → bool¶

Check if peptide flip can be done at position, if it can flip poistion and return true else return false

C++: protocols::cyclic_peptide::CrankshaftFlipMover::try_peptide_flip(class core::pose::Pose &, unsigned long, unsigned long) –> bool

try_peptoid_flip(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, pose: pyrosetta.rosetta.core.pose.Pose, res1_index: int, res2_index: int) → bool¶

Check if peptoid flip can be done at position, if it can flip poistion and return true else return false

C++: protocols::cyclic_peptide::CrankshaftFlipMover::try_peptoid_flip(class core::pose::Pose &, unsigned long, unsigned long) –> bool

try_pre_gly_flip(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrankshaftFlipMover, pose: pyrosetta.rosetta.core.pose.Pose, res1_index: int, res2_index: int) → bool¶

Check if pre-gly flip can be done at position, if it can flip poistion and return true else return false

C++: protocols::cyclic_peptide::CrankshaftFlipMover::try_pre_gly_flip(class core::pose::Pose &, unsigned long, unsigned long) –> bool

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.cyclic_peptide.CrankshaftFlipMoverCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.CreateAngleConstraint¶

Bases: Mover

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

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

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.cyclic_peptide.CreateAngleConstraint) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::CreateAngleConstraint::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.cyclic_peptide.CreateAngleConstraint) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::CreateAngleConstraint::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¶

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.cyclic_peptide.CreateAngleConstraint) → str¶: C++: protocols::cyclic_peptide::CreateAngleConstraint::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::cyclic_peptide::CreateAngleConstraint::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.CreateAngleConstraint, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::cyclic_peptide::CreateAngleConstraint::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::cyclic_peptide::CreateAngleConstraint::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(self: pyrosetta.rosetta.protocols.cyclic_peptide.CreateAngleConstraint, : pyrosetta.rosetta.utility.vector1_unsigned_long, : pyrosetta.rosetta.utility.vector1_std_string, : pyrosetta.rosetta.utility.vector1_unsigned_long, : pyrosetta.rosetta.utility.vector1_std_string, : pyrosetta.rosetta.utility.vector1_unsigned_long, : pyrosetta.rosetta.utility.vector1_std_string, : pyrosetta.rosetta.utility.vector1_std_string) → None¶: C++: protocols::cyclic_peptide::CreateAngleConstraint::set(class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<std::string, class std::allocator<std::string > >, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<std::string, class std::allocator<std::string > >, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<std::string, class std::allocator<std::string > >, class utility::vector1<std::string, class std::allocator<std::string > >) –> 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

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.cyclic_peptide.CreateAngleConstraintCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.CreateDistanceConstraint¶

Bases: Mover

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

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

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.cyclic_peptide.CreateDistanceConstraint) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::CreateDistanceConstraint::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.cyclic_peptide.CreateDistanceConstraint) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::CreateDistanceConstraint::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¶

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.cyclic_peptide.CreateDistanceConstraint) → str¶: C++: protocols::cyclic_peptide::CreateDistanceConstraint::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::cyclic_peptide::CreateDistanceConstraint::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.CreateDistanceConstraint, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::cyclic_peptide::CreateDistanceConstraint::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::cyclic_peptide::CreateDistanceConstraint::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(self: pyrosetta.rosetta.protocols.cyclic_peptide.CreateDistanceConstraint, res1: pyrosetta.rosetta.utility.vector1_unsigned_long, atom1: pyrosetta.rosetta.utility.vector1_std_string, res2: pyrosetta.rosetta.utility.vector1_unsigned_long, atom2: pyrosetta.rosetta.utility.vector1_std_string, cst_function: pyrosetta.rosetta.utility.vector1_std_string) → None¶

Setter for options for this mover, so that it can be called from: outside of RosettaScripts.

C++: protocols::cyclic_peptide::CreateDistanceConstraint::set(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<std::string, class std::allocator<std::string > > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<std::string, class std::allocator<std::string > > &, const class utility::vector1<std::string, class std::allocator<std::string > > &) –> 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

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.cyclic_peptide.CreateDistanceConstraintCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.CreateTorsionConstraint¶

Bases: Mover

ambiguous(*args, **kwargs)¶

Overloaded function.

ambiguous(self: pyrosetta.rosetta.protocols.cyclic_peptide.CreateTorsionConstraint, setting: bool) -> None

C++: protocols::cyclic_peptide::CreateTorsionConstraint::ambiguous(bool) –> void

ambiguous(self: pyrosetta.rosetta.protocols.cyclic_peptide.CreateTorsionConstraint) -> bool

C++: protocols::cyclic_peptide::CreateTorsionConstraint::ambiguous() const –> bool

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

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

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.cyclic_peptide.CreateTorsionConstraint) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::CreateTorsionConstraint::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.cyclic_peptide.CreateTorsionConstraint) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::CreateTorsionConstraint::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¶

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.cyclic_peptide.CreateTorsionConstraint) → str¶: C++: protocols::cyclic_peptide::CreateTorsionConstraint::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::cyclic_peptide::CreateTorsionConstraint::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.CreateTorsionConstraint, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::cyclic_peptide::CreateTorsionConstraint::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::cyclic_peptide::CreateTorsionConstraint::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 function: allows the mover to be set up outside of a RosettaScripts context.

C++: protocols::cyclic_peptide::CreateTorsionConstraint::set(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<std::string, class std::allocator<std::string > > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<std::string, class std::allocator<std::string > > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<std::string, class std::allocator<std::string > > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<std::string, class std::allocator<std::string > > &, const class utility::vector1<std::string, class std::allocator<std::string > > &) –> 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

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.cyclic_peptide.CreateTorsionConstraintCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker¶

Bases: pybind11_object

Enumeration of allowed crosslinkers.

Members:

no_crosslinker

TBMB

One_Four_BBMB

TMA

thioether

tetrahedral_metal

octahedral_metal

trigonal_planar_metal

trigonal_pyramidal_metal

square_planar_metal

square_pyramidal_metal

unknown_crosslinker

end_of_crosslinker_list

One_Four_BBMB = <CrossLinker.One_Four_BBMB: 3>¶

TBMB = <CrossLinker.TBMB: 2>¶

TMA = <CrossLinker.TMA: 4>¶

end_of_crosslinker_list = <CrossLinker.unknown_crosslinker: 12>¶

property name¶

no_crosslinker = <CrossLinker.no_crosslinker: 1>¶

octahedral_metal = <CrossLinker.octahedral_metal: 7>¶

square_planar_metal = <CrossLinker.square_planar_metal: 10>¶

square_pyramidal_metal = <CrossLinker.square_pyramidal_metal: 11>¶

tetrahedral_metal = <CrossLinker.tetrahedral_metal: 6>¶

thioether = <CrossLinker.thioether: 5>¶

trigonal_planar_metal = <CrossLinker.trigonal_planar_metal: 8>¶

trigonal_pyramidal_metal = <CrossLinker.trigonal_pyramidal_metal: 9>¶

unknown_crosslinker = <CrossLinker.unknown_crosslinker: 12>¶

property value¶

class pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover¶

Bases: Mover

This mover links two or more residues with a (possibly symmetric) cross-linker. It adds the crosslinker, sets up constraints, optionally packs and energy-mimizes it into place (packing/minimizing only the crosslinker and the side-chains to which it connects), and then optionally relaxes the whole structure.

add_linker(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → bool¶

Get whether we’re adding the linker.

C++: protocols::cyclic_peptide::CrosslinkerMover::add_linker() const –> bool

apply(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Apply the mover

C++: protocols::cyclic_peptide::CrosslinkerMover::apply(class core::pose::Pose &) –> void

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

static class_name() → str¶

Show the contents of the Mover

C++: protocols::cyclic_peptide::CrosslinkerMover::class_name() –> std::string

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

required in the context of the parser/scripting scheme

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

constrain_linker(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → bool¶

Get whether we’re adding the linker constraints.

C++: protocols::cyclic_peptide::CrosslinkerMover::constrain_linker() const –> bool

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>

do_final_fastrelax(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → bool¶

Get whether we’re doing a final FastRelax on the whole structure.

C++: protocols::cyclic_peptide::CrosslinkerMover::do_final_fastrelax() const –> bool

final_frlx_rounds(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → int¶

Get the number of rounds of FastRelax to apply at the end.

C++: protocols::cyclic_peptide::CrosslinkerMover::final_frlx_rounds() const –> unsigned long

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

required in the context of the parser/scripting scheme

C++: protocols::cyclic_peptide::CrosslinkerMover::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_crosslinker_enum(name: str) → pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker¶

Given a CrossLinker name, get its enum.

C++: protocols::cyclic_peptide::CrosslinkerMover::get_crosslinker_enum(const std::string &) –> enum protocols::cyclic_peptide::CrossLinker

static get_crosslinker_name(crosslinker: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker) → str¶

Given a CrossLinker enum, get its name.

C++: protocols::cyclic_peptide::CrosslinkerMover::get_crosslinker_name(const enum protocols::cyclic_peptide::CrossLinker) –> std::string

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.cyclic_peptide.CrosslinkerMover) → str¶

Get the name of the Mover

C++: protocols::cyclic_peptide::CrosslinkerMover::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

linker_name(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → str¶

Get the linker name.

C++: protocols::cyclic_peptide::CrosslinkerMover::linker_name() const –> std::string

metal_type(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → str¶

For metal-mediated crosslinkers, what metal mediates the crosslink?

C++: protocols::cyclic_peptide::CrosslinkerMover::metal_type() const –> const std::string &

static mover_name() → str¶

Returns the name of this Mover.

C++: protocols::cyclic_peptide::CrosslinkerMover::mover_name() –> std::string

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

pack_and_minimize_linker_and_sidechains(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → bool¶

Get whether we’re packing and minimizing the linker and the side-chains to which it is connected.

C++: protocols::cyclic_peptide::CrosslinkerMover::pack_and_minimize_linker_and_sidechains() const –> bool

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Parse XML tag (to use this Mover in Rosetta Scripts).

C++: protocols::cyclic_peptide::CrosslinkerMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, citations: pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶

Provide information on what options are available in XML tag.

C++: protocols::cyclic_peptide::CrosslinkerMover::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

residue_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶

Get the residue selector that this mover uses.

C++: protocols::cyclic_peptide::CrosslinkerMover::residue_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

scorefxn(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → pyrosetta.rosetta.core.scoring.ScoreFunction¶

Get the scorefunction to use for packing and minimization.

C++: protocols::cyclic_peptide::CrosslinkerMover::scorefxn() const –> class std::shared_ptr<const class core::scoring::ScoreFunction>

set_behaviour(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, add_linker: bool, constrain_linker: bool, pack_and_minimize_linker_and_sidechains: bool, do_final_fastrelax: bool) → None¶

Set the behaviour of this mover.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_behaviour(const bool, const bool, const bool, 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_filter_behaviour(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, filter_by_sidechain_distance: bool, filter_by_constraints_energy: bool, filter_by_total_score: bool, filter_by_total_score_cutoff_energy: float, sidechain_distance_filter_multiplier: float, constraints_energy_filter_multiplier: float) → None¶

Set the filtering behaviour of this mover.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_filter_behaviour(const bool, const bool, const bool, const double, const double, const double) –> void

set_final_frlx_rounds(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, rounds_in: int) → None¶

Set the number of rounds of FastRelax to apply at the end.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_final_frlx_rounds(const unsigned long) –> 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_linker_name(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, name_in: str) → None¶

Set the linker name.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_linker_name(const std::string &) –> void

set_metal_type(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, metal_in: str) → None¶

For metal-mediated crosslinkers, set what metal mediates the crosslink.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_metal_type(const std::string &) –> 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_residue_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set the residue selector to use.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, sfxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set the scorefunction to use for packing and minimization.

Cloned at apply time. (That is, the scorefunction is shared until apply time).

C++: protocols::cyclic_peptide::CrosslinkerMover::set_scorefxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_sidechain_frlx_rounds(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, rounds_in: int) → None¶

Set the number of rounds of FastRelax to apply when minimizing the linker and the: side-chains that connect to it.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_sidechain_frlx_rounds(const unsigned long) –> void

set_symm_count(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, count_in: int) → None¶

Set the symmetry copy count.

For example, symm_type_=’C’ and symm_count_=3 would specify C3 symmetry. A value of 1 means asymmetry. 1 by default.

Deliberately a signed int.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_symm_count(const int) –> void

set_symm_type(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, type_in: str) → None¶

Set the symmety type.

‘C’ for cylic, ‘S’ for mirror cyclic, ‘D’ for dihedral, ‘A’ for asymmetric.

‘A’ (asymmetric) by default.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_symm_type(const char) –> void

set_symmetry(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, symmetry_in: str) → None¶

Parse a string with a symmetry type (e.g. “C3”) and set the symmetry accordingly.

C++: protocols::cyclic_peptide::CrosslinkerMover::set_symmetry(const std::string &) –> 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.cyclic_peptide.CrosslinkerMover) -> None
show(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, output: pyrosetta.rosetta.std.ostream) -> None

Show the contents of the Mover

C++: protocols::cyclic_peptide::CrosslinkerMover::show(std::ostream &) const –> void

sidechain_frlx_rounds(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → int¶

Get the number of rounds of FastRelax to apply when minimizing the linker and the: side-chains that connect to it.

C++: protocols::cyclic_peptide::CrosslinkerMover::sidechain_frlx_rounds() const –> unsigned long

symm_count(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → int¶

Get the symmetry copy count.

For example, symm_type_=’C’ and symm_count_=3 would specify C3 symmetry. A value of 1 means asymmetry. 1 by default.

C++: protocols::cyclic_peptide::CrosslinkerMover::symm_count() const –> unsigned long

symm_type(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) → str¶

Get the symmetry type.

‘C’ for cylic, ‘S’ for mirror cyclic, ‘D’ for dihedral, ‘A’ for asymmetric.

‘A’ (asymmetric) by default.

C++: protocols::cyclic_peptide::CrosslinkerMover::symm_type() const –> char

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.cyclic_peptide.CrosslinkerMoverCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover¶

Bases: Mover

A mover that takes a cyclic peptide and alters its position (rigid-body transform), superimposing it on a cyclic permutation or reverse cyclic permutation of itself.

apply(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Apply the mover

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::apply(class core::pose::Pose &) –> void

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

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

required in the context of the parser/scripting scheme

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::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.cyclic_peptide.CycpepRigidBodyPermutationMover) → pyrosetta.rosetta.protocols.moves.Mover¶

required in the context of the parser/scripting scheme

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::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¶

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.cyclic_peptide.CycpepRigidBodyPermutationMover) → str¶: C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::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 > > &

inversion_random(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover) → bool¶

Get whether we are only overlaying the peptide on a permuted version of itself (false) or: whether we are allowed to consider overlays on a permuted version of the reverse sequence (true). Only used in randomization mode.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::inversion_random() const –> bool

inversion_setting(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover) → bool¶

Set whether we are overlaying the peptide on a permuted version of itself (false) or on: a permuted version of the reverse sequence (true). Only used in setting mode.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::inversion_setting() const –> bool

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

mover_mode(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover) → pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMoverMode¶

Get how we will permute the peptide, by enum: setting its permutation or randomizing it.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::mover_mode() const –> enum protocols::cyclic_peptide::CycpepRigidBodyPermutationMoverMode

static mover_name() → str¶: C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

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

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

permutation_setting(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover) → int¶

Get how much we are permuting the peptide in setting mode. If inversion_setting is

false, this is residues in the forward direction; if it is true, this is residues in the reverse direction.

Deliberately signed.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::permutation_setting() const –> long

provide_citation_info(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, citations: pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

This mover is unpublished. It returns Vikram K. Mulligan as its author.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶

Describe the XML interface for this mover, in a machine-readable way that permits: automatic checking of user inputs.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

random_orientation_perturbation(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover) → float¶

Get whether we should add a small random perturbation to the peptide’s orientation.

The default, 0.0, means no perturbation. Larger values set the magnitude of the random roll, in degrees. The roll is about the peptide centroid.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::random_orientation_perturbation() const –> double

random_position_offset(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover) → float¶

Get whether we should add a small random offset to the peptide’s position.

The default, 0.0, means no offset. Larger values set the magnitude of the random displacement, in Angstroms.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::random_position_offset() const –> double

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

residue_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶

Get the residue selector to select a cyclic peptide that is a part of a pose.

Could be nullptr if no selector is set.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::residue_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

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_inversion_random(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, inversion_random: bool) → None¶

Set whether we are only overlaying the peptide on a permuted version of itself (false) or: whether we are allowed to consider overlays on a permuted version of the reverse sequence (true). Only used in randomization mode.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::set_inversion_random(const bool) –> void

set_inversion_setting(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, inversion_setting: bool) → None¶

Set whether we are overlaying the peptide on a permuted version of itself (false) or on: a permuted version of the reverse sequence (true). Only used in setting mode.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::set_inversion_setting(const bool) –> void

set_mover_mode(*args, **kwargs)¶

Overloaded function.

set_mover_mode(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, setting: str) -> None

Set how we will permute the peptide, by string: setting its permutation or randomizing it.

Throws if string not recognized.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::set_mover_mode(const std::string &) –> void

set_mover_mode(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, setting: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMoverMode) -> None

Set how we will permute the peptide, by enum: setting its permutation or randomizing it.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::set_mover_mode(const enum protocols::cyclic_peptide::CycpepRigidBodyPermutationMoverMode) –> 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_permutation_setting(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, offset: int) → None¶

Set how much we are permuting the peptide in setting mode. If inversion_setting is

false, this is residues in the forward direction; if it is true, this is residues in the reverse direction.

Deliberately signed.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::set_permutation_setting(const long) –> void

set_random_orientation_perturbation(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, perturbation: float) → None¶

Set whether we should add a small random perturbation to the peptide’s orientation.

The default, 0.0, means no perturbation. Larger values set the magnitude of the random roll, in degrees. The roll is about the peptide centroid.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::set_random_orientation_perturbation(const double) –> void

set_random_position_offset(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, offset: float) → None¶

Set whether we should add a small random offset to the peptide’s position.

The default, 0.0, means no offset. Larger values set the magnitude of the random displacement, in Angstroms.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::set_random_position_offset(const double) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set a residue selector to select a cyclic peptide that is a part of a pose.

Input selector is used directly, not cloned. Pass nullptr to disable.

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> 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.cyclic_peptide.CycpepRigidBodyPermutationMover) -> None
show(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMover, output: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::cyclic_peptide::CycpepRigidBodyPermutationMover::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.cyclic_peptide.CycpepRigidBodyPermutationMoverCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMoverMode¶

Bases: pybind11_object

An enum for the modes for this mover.

If you add to this list, update the string_from_cycpep_rigid_body_permutation_mover_mode() function.

Members:

SET_PERMUTATION

RANDOM_PERMUTATION

N_MODES

UNKNOWN_MODE

N_MODES = <CycpepRigidBodyPermutationMoverMode.RANDOM_PERMUTATION: 2>¶

RANDOM_PERMUTATION = <CycpepRigidBodyPermutationMoverMode.RANDOM_PERMUTATION: 2>¶

SET_PERMUTATION = <CycpepRigidBodyPermutationMoverMode.SET_PERMUTATION: 1>¶

UNKNOWN_MODE = <CycpepRigidBodyPermutationMoverMode.UNKNOWN_MODE: 3>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter¶

Bases: Filter

A filter that examines a cyclic peptide’s structure and returns TRUE if and only if it has a desired backbone symmetry.

angle_threshold(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter) → float¶

The cutoff, in degrees, that two mainchain dihedral values must lie within in order for two residues to: be considered to have the “same” value for that mainchain degree of freedom.

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::angle_threshold() const –> const double &

apply(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

returns true if the structure passes the filter, false otherwise

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

static class_name() → str¶: C++: protocols::cyclic_peptide::CycpepSymmetryFilter::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.cyclic_peptide.CycpepSymmetryFilter) → pyrosetta.rosetta.protocols.filters.Filter¶

required in the context of the parser/scripting scheme

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

fresh_instance(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter) → pyrosetta.rosetta.protocols.filters.Filter¶

required in the context of the parser/scripting scheme

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::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

mirror_symm(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter) → bool¶

Gets whether we’re considering mirror (e.g. s4, s6) or non-mirror: (e.g. c4, c6) symmetry.

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::mirror_symm() const –> bool

name(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter) → str¶: C++: protocols::cyclic_peptide::CycpepSymmetryFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

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

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

report(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter, os: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

allows printing data to a stream

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

required for reporting score values

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::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

selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶

Gets the residue selector.

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

set_angle_threshold(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter, setting: float) → None¶

Set the cutoff, in degrees, that two mainchain dihedral values must lie within in order for two residues to: be considered to have the “same” value for that mainchain degree of freedom.

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::set_angle_threshold(const double &) –> void

set_mirror_symm(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter, symm_in: bool) → None¶

Sets whether we’re considering mirror (e.g. s4, s6) or non-mirror: (e.g. c4, c6) symmetry.

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::set_mirror_symm(const bool) –> void

set_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter, selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Sets the residue selector.

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::set_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_symm_repeats(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter, repeats_in: int) → None¶

Sets the repeats in the symmetry that we’re looking for: (e.g. 2 for c2 or s2 symmetry, 3 for c3, etc.).

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::set_symm_repeats(const unsigned long) –> 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

symm_repeats(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter) → int¶

Gets the repeats in the symmetry that we’re looking for: (e.g. 2 for c2 or s2 symmetry, 3 for c3, etc.).

C++: protocols::cyclic_peptide::CycpepSymmetryFilter::symm_repeats() const –> unsigned long

class pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilterCreator¶

Bases: FilterCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.FlipChiralityMover¶

Bases: Mover

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

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

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.cyclic_peptide.FlipChiralityMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::FlipChiralityMover::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.cyclic_peptide.FlipChiralityMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::FlipChiralityMover::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_center(self: pyrosetta.rosetta.protocols.cyclic_peptide.FlipChiralityMover, : pyrosetta.rosetta.utility.vector1_bool, : pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: protocols::cyclic_peptide::FlipChiralityMover::get_center(class utility::vector1<bool, class std::allocator<bool> >, const class core::pose::Pose &) –> const class numeric::xyzVector<double> &

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.cyclic_peptide.FlipChiralityMover) → str¶: C++: protocols::cyclic_peptide::FlipChiralityMover::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_normal(self: pyrosetta.rosetta.protocols.cyclic_peptide.FlipChiralityMover) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: protocols::cyclic_peptide::FlipChiralityMover::get_normal() –> const class numeric::xyzVector<double> &

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::cyclic_peptide::FlipChiralityMover::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.FlipChiralityMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::cyclic_peptide::FlipChiralityMover::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::cyclic_peptide::FlipChiralityMover::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_center(self: pyrosetta.rosetta.protocols.cyclic_peptide.FlipChiralityMover, : float, : float, : float) → None¶: C++: protocols::cyclic_peptide::FlipChiralityMover::set_center(const double &, const double &, const double &) –> 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_normal(self: pyrosetta.rosetta.protocols.cyclic_peptide.FlipChiralityMover, : float, : float, : float) → None¶: C++: protocols::cyclic_peptide::FlipChiralityMover::set_normal(const double &, const double &, const double &) –> void

set_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.FlipChiralityMover, selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶: C++: protocols::cyclic_peptide::FlipChiralityMover::set_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> 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.cyclic_peptide.FlipChiralityMoverCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter¶

Bases: Filter

This filter flags poses containing more than two hydrogen bonds to an oxygen atom, a common pathology that results from Rosetta’s pairwise-decomposible scorefunction, which can’t penalize excessive hydrogen bonds.

acceptor_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶

Get the residue selector for acceptor residues.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::acceptor_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

apply(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

Returns true if the structure passes the filter, false otherwise.

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

static class_name() → str¶: C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::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.cyclic_peptide.OversaturatedHbondAcceptorFilter) → pyrosetta.rosetta.protocols.filters.Filter¶

Required in the context of the parser/scripting scheme.

Make a copy of this object and return an owning pointer to the copy.

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

consider_mainchain_only(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) → bool¶

Get whether we only consider mainchain hydrogen bond: donors and acceptors.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::consider_mainchain_only() const –> bool

donor_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶

Get the residue selector for donor residues.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::donor_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

fresh_instance(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) → pyrosetta.rosetta.protocols.filters.Filter¶

Required in the context of the parser/scripting scheme.

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

get_name(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) → str¶: C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::get_name() const –> std::string

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

hbond_energy_cutoff(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) → float¶

Get the threshold for considering something to be a: hydrogen bond.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::hbond_energy_cutoff() const –> const double &

max_allowed_oversaturated(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) → int¶

Get the maximum allowed number of instances of an oversaturated: hydrogen bond acceptor.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::max_allowed_oversaturated() const –> unsigned long

name(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) → str¶: C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Parse XML tag (to use this Mover in RosettaScripts).

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

report(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, os: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Allows printing a summary of this filter to a stream.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

Required for reporting score values.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::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

scorefxn(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) → pyrosetta.rosetta.core.scoring.ScoreFunction¶

Get the scorefunction.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::scorefxn() const –> class std::shared_ptr<const class core::scoring::ScoreFunction>

set_acceptor_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, acceptor_selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set the residue selector for acceptor residues.

Clones the input.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::set_acceptor_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_consider_mainchain_only(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, input_setting: bool) → None¶

Set whether we only consider mainchain hydrogen bond: donors and acceptors.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::set_consider_mainchain_only(const bool) –> void

set_donor_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, donor_selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set the residue selector for donor residues.

Clones the input.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::set_donor_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_hbond_energy_cutoff(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, input_value: float) → None¶

Set the threshold for considering something to be a: hydrogen bond.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::set_hbond_energy_cutoff(const double &) –> void

set_max_allowed_oversaturated(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, max_allowed: int) → None¶

Set the maximum allowed number of instances of an oversaturated: hydrogen bond acceptor.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::set_max_allowed_oversaturated(const unsigned long) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, sfxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set the scorefunction.

Clones the input.

C++: protocols::cyclic_peptide::OversaturatedHbondAcceptorFilter::set_scorefxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> 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

class pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilterCreator¶

Bases: FilterCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.PSM_StubMode¶

Bases: pybind11_object

Members:

PSM_append

PSM_prepend

PSM_insert

PSM_append = <PSM_StubMode.PSM_append: 0>¶

PSM_insert = <PSM_StubMode.PSM_insert: 2>¶

PSM_prepend = <PSM_StubMode.PSM_prepend: 1>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover¶

Bases: Mover

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

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

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.cyclic_peptide.PeptideCyclizeMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::PeptideCyclizeMover::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.cyclic_peptide.PeptideCyclizeMover) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::PeptideCyclizeMover::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¶

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.cyclic_peptide.PeptideCyclizeMover) → str¶: C++: protocols::cyclic_peptide::PeptideCyclizeMover::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::cyclic_peptide::PeptideCyclizeMover::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::cyclic_peptide::PeptideCyclizeMover::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::cyclic_peptide::PeptideCyclizeMover::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_angle(*args, **kwargs)¶

Overloaded function.

set_angle(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : int, : str, : int, : str, : int, : str, : str) -> None

C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_angle(unsigned long, std::string, unsigned long, std::string, unsigned long, std::string, std::string) –> void

set_angle(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : str) -> None

C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_angle(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, std::string) –> void

set_bond(*args, **kwargs)¶

Overloaded function.

set_bond(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : int, : str, : int, : str, : bool, : bool) -> None

C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_bond(unsigned long, std::string, unsigned long, std::string, bool, bool) –> void

set_bond(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : bool, : bool) -> None

C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_bond(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, bool, 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_default(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover) → None¶: C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_default() –> void

set_distance(*args, **kwargs)¶

Overloaded function.

set_distance(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : int, : str, : int, : str, : str) -> None

C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_distance(unsigned long, std::string, unsigned long, std::string, std::string) –> void

set_distance(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : str) -> None

C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_distance(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, 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_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶: C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_torsion(*args, **kwargs)¶

Overloaded function.

set_torsion(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : int, : str, : int, : str, : int, : str, : int, : str, : str) -> None

C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_torsion(unsigned long, std::string, unsigned long, std::string, unsigned long, std::string, unsigned long, std::string, std::string) –> void

set_torsion(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideCyclizeMover, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : str, : str) -> None

C++: protocols::cyclic_peptide::PeptideCyclizeMover::set_torsion(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, std::string, std::string) –> 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.cyclic_peptide.PeptideCyclizeMoverCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter¶

Bases: Filter

A filter that thinly wraps the PeptideInternalHbondsMetric.

apply(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

returns true if the structure has internal hbonds equal to or greater than: the cutoff, false otherwise.

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

backbone_backbone(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → bool¶

Get whether we’re counting backbone-backbone hbonds:

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::backbone_backbone() const –> bool

backbone_sidechain(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → bool¶

Get whether we’re counting backbone-sidechain hbonds:

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::backbone_sidechain() const –> bool

static class_name() → str¶: C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::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.cyclic_peptide.PeptideInternalHbondsFilter) → pyrosetta.rosetta.protocols.filters.Filter¶

Make a copy of this filter and return an owning pointer to the copy.

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

exclusion_distance(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → int¶

Get the number of residues apart in terms of covalent connectivity that two residues have to be in order for their

hydrogen bonds to be counted.

Defaults to 1.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::exclusion_distance() const –> unsigned long

fresh_instance(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → pyrosetta.rosetta.protocols.filters.Filter¶

Required in the context of the parser/scripting scheme.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::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

hbond_cutoff(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → int¶

Get the threshold number of internal hydrogen bonds, below which the filter fails.

Defaults to 1.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::hbond_cutoff() const –> unsigned long

hbond_energy_cutoff(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → float¶

Get the energy cutoff for counting a hydrogen bond.

Defaults to -0.25.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::hbond_energy_cutoff() const –> double

hbond_metric(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → protocols::cyclic_peptide::PeptideInternalHbondsMetric¶

Access the internal PeptideInternalHbondsMetric used by this filter (non-const access).

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::hbond_metric() –> class protocols::cyclic_peptide::PeptideInternalHbondsMetric &

name(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → str¶: C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Parse XML tag (to use this Filter in Rosetta Scripts).

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

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

Provide the citation.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶

Describe the XML interface in a machine-readable way.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, os: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

allows printing data to a stream.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

Required for reporting score values.

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

residue_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶

Get the scorefunction for selecting the peptide. If this nullptr, whole pose is counted.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::residue_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

scorefxn(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → pyrosetta.rosetta.core.scoring.ScoreFunction¶

Get the scorefunction for identifying hydrogen bonds. Note that if this is nullptr, the: default scorefunction is used.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::scorefxn() const –> class std::shared_ptr<const class core::scoring::ScoreFunction>

set_exclusion_distance(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, setting: int) → None¶

Set the number of residues apart in terms of covalent connectivity that two residues have to be in order for their

hydrogen bonds to be counted.

Defaults to 1.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::set_exclusion_distance(const unsigned long) –> void

set_hbond_cutoff(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, setting: int) → None¶

Set the threshold number of internal hydrogen bonds, below which the filter fails.

Defaults to 1.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::set_hbond_cutoff(const unsigned long) –> void

set_hbond_energy_cutoff(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, setting: float) → None¶

Set the energy cutoff for counting a hydrogen bond.

Defaults to -0.25.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::set_hbond_energy_cutoff(const double) –> void

set_hbond_types(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, backbone_backbone_setting: bool, backbone_sidechain_setting: bool, sidechain_sidechain_setting: bool) → None¶

Set whether we’re counting backbone-backbone, backbone-sidechain, and sidechain-sidechain hydrogen bonds.

Throws if all are set to false. Defaults to only backbone-backbone being true.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::set_hbond_types(const bool, const bool, const bool) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, res_selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set the scorefunction for selecting the peptide. If this is not called, whole pose is counted.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::set_residue_selector(const class std::shared_ptr<const class core::select::residue_selector::ResidueSelector> &) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter, sfxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set the scorefunction for identifying hydrogen bonds. If this is not called, the default scorefunction is used.

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::set_scorefxn(const class std::shared_ptr<const class core::scoring::ScoreFunction> &) –> 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

sidechain_sidechain(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilter) → bool¶

Get whether we’re counting sidechain-sidechain hbonds:

C++: protocols::cyclic_peptide::PeptideInternalHbondsFilter::sidechain_sidechain() const –> bool

class pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsFilterCreator¶

Bases: FilterCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric¶

Bases: RealMetric

A simple metric for measuring the backbone hydrogen bonds within a peptide backbone, ignoring hydrogen bonds to other parts of a pose. Note that this metric does not count intra-residue hydrogen bonds.

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, suffix: str) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, suffix: str, override_existing_data: bool) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, out_label: str, pose: pyrosetta.rosetta.core.pose.Pose) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, out_label: str, pose: pyrosetta.rosetta.core.pose.Pose, override_existing_data: bool) -> None

Calculate the metric and add it to the pose as a score.

labeled as out_label.

Score is added to the SimpleMetricData cache: Data is output into the final score file, but can be accessed if needed through the cache.

C++: core::simple_metrics::RealMetric::apply(const std::string &, class core::pose::Pose &, bool) const –> void

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

backbone_backbone(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → bool¶

Get whether we’re counting backbone-backbone hbonds:

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::backbone_backbone() const –> bool

backbone_sidechain(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → bool¶

Get whether we’re counting backbone-sidechain hbonds:

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::backbone_sidechain() const –> bool

cached_calculate(*args, **kwargs)¶

Overloaded function.

cached_calculate(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, use_cache: bool) -> float
cached_calculate(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, use_cache: bool, prefix: str) -> float
cached_calculate(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, use_cache: bool, prefix: str, suffix: str) -> float
cached_calculate(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, use_cache: bool, prefix: str, suffix: str, fail_on_missing_cache: bool) -> float

Grab the data from the pose if it exists or calculate the metric

If use_cache is true, we will attempt to pull the data from the pose. If fail_on_missing_cache is true, we will fail, otherwise, we will calculate the metric.

This function is meant to support caching metrics, so values do not need to be calculated twice,
for example in SimpleMetricFilter/Features or code-wise where data takes a while to calculate and can be reused.

C++: core::simple_metrics::RealMetric::cached_calculate(const class core::pose::Pose &, bool, std::string, std::string, bool) const –> double

calculate(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

Calculate the metric.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::calculate(const class core::pose::Pose &) const –> double

clone(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → pyrosetta.rosetta.core.simple_metrics.SimpleMetric¶

Duplicate this object, and return a smart pointer to the copy.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::clone() const –> class std::shared_ptr<class core::simple_metrics::SimpleMetric>

static complex_type_generator_for_simple_metric(: utility::tag::XMLSchemaDefinition) → utility::tag::XMLSchemaComplexTypeGenerator¶: C++: core::simple_metrics::SimpleMetric::complex_type_generator_for_simple_metric(class utility::tag::XMLSchemaDefinition &) –> class std::shared_ptr<class utility::tag::XMLSchemaComplexTypeGenerator>

configure_from_filter_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Configure this metric from the tag passed to the companion filter (the: PeptideInternalHbondsFilter).

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::configure_from_filter_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

exclusion_distance(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → int¶

Get the number of residues apart in terms of covalent connectivity that two residues have to be in order for their

hydrogen bonds to be counted.

Defaults to 1.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::exclusion_distance() const –> unsigned long

get_custom_type(self: pyrosetta.rosetta.core.simple_metrics.SimpleMetric) → str¶

Output data name will be prefix+custom_type+type+suffix

C++: core::simple_metrics::SimpleMetric::get_custom_type() const –> std::string

get_final_sm_type(self: pyrosetta.rosetta.core.simple_metrics.SimpleMetric) → str¶

Get the final name of this metric including its simple_metric_type_ name and any set custom type.

C++: core::simple_metrics::SimpleMetric::get_final_sm_type() const –> std::string

get_metric_names(self: pyrosetta.rosetta.core.simple_metrics.RealMetric) → pyrosetta.rosetta.utility.vector1_std_string¶

Get the metric name(s) that this Metric will calculate

C++: core::simple_metrics::RealMetric::get_metric_names() const –> class utility::vector1<std::string, class std::allocator<std::string > >

hbond_energy_cutoff(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → float¶

Get the energy cutoff for counting a hydrogen bond.

Defaults to -0.25.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::hbond_energy_cutoff() const –> double

metric(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → str¶

Return text indicating what we’re measuring.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::metric() const –> std::string

name(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → str¶

Name of the class

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::name() const –> std::string

static name_static() → str¶

Name of the class for creator.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::name_static() –> std::string

parse_base_tag(self: pyrosetta.rosetta.core.simple_metrics.SimpleMetric, tag: utility::tag::Tag) → None¶

Parse the base class tag. Keep required interface for parse_my_tag.

C++: core::simple_metrics::SimpleMetric::parse_base_tag(class std::shared_ptr<const class utility::tag::Tag>) –> void

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

called by parse_my_tag – should not be used directly

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

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

Provide the citation.

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

static provide_shared_xml_schema_elements(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None¶

Provide descriptions of XML interface elements shared between this metric and the companion filter.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::provide_shared_xml_schema_elements(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶

Provide a description of the XML interface.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric, outstream: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

allows printing data to a stream.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::report(std::ostream &, const class core::pose::Pose &) const –> void

residue_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶

Get the scorefunction for selecting the peptide. If this nullptr, whole pose is counted.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::residue_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

scorefxn(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → pyrosetta.rosetta.core.scoring.ScoreFunction¶

Get the scorefunction for identifying hydrogen bonds. Note that if this is nullptr, the: default scorefunction is used.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::scorefxn() const –> class std::shared_ptr<const class core::scoring::ScoreFunction>

set_custom_type(self: pyrosetta.rosetta.core.simple_metrics.SimpleMetric, custom_type: str) → None¶: C++: core::simple_metrics::SimpleMetric::set_custom_type(const std::string &) –> void

set_exclusion_distance(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric, setting: int) → None¶

Set the number of residues apart in terms of covalent connectivity that two residues have to be in order for their

hydrogen bonds to be counted.

Defaults to 1.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::set_exclusion_distance(const unsigned long) –> void

set_hbond_energy_cutoff(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric, setting: float) → None¶

Set the energy cutoff for counting a hydrogen bond.

Defaults to -0.25.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::set_hbond_energy_cutoff(const double) –> void

set_hbond_types(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric, backbone_backbone_setting: bool, backbone_sidechain_setting: bool, sidechain_sidechain_setting: bool) → None¶

Set whether we’re counting backbone-backbone, backbone-sidechain, and sidechain-sidechain hydrogen bonds.

Throws if all are set to false. Defaults to only backbone-backbone being true.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::set_hbond_types(const bool, const bool, const bool) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric, res_selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set the scorefunction for selecting the peptide. If this is not called, whole pose is counted.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::set_residue_selector(const class std::shared_ptr<const class core::select::residue_selector::ResidueSelector> &) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric, sfxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set the scorefunction for identifying hydrogen bonds. If this is not called, the default scorefunction is used.

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::set_scorefxn(const class std::shared_ptr<const class core::scoring::ScoreFunction> &) –> void

sidechain_sidechain(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetric) → bool¶

Get whether we’re counting sidechain-sidechain hbonds:

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetric::sidechain_sidechain() const –> bool

simple_metric_type(self: pyrosetta.rosetta.core.simple_metrics.SimpleMetric) → str¶: C++: core::simple_metrics::SimpleMetric::simple_metric_type() const –> std::string

class pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetricCreator¶

Bases: SimpleMetricCreator

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

create_simple_metric(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetricCreator) → pyrosetta.rosetta.core.simple_metrics.SimpleMetric¶

Instantiate a particular SimpleMetric

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetricCreator::create_simple_metric() const –> class std::shared_ptr<class core::simple_metrics::SimpleMetric>

keyname(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideInternalHbondsMetricCreator) → str¶

Return a string that will be used to instantiate the particular SimpleMetric

C++: protocols::cyclic_peptide::PeptideInternalHbondsMetricCreator::keyname() const –> std::string

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

class pyrosetta.rosetta.protocols.cyclic_peptide.PeptideStubMover¶

Bases: Mover

add_residue(*args, **kwargs)¶

Overloaded function.

add_residue(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideStubMover, stubmode: str, resname: str, position: int, jumpmode: bool, connecting_atom: str, repeat: int, anchor_rsd: int, anchor_rsd_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, anchor_atom: str) -> None

Adds a residue to the list of residues to be appended, prepended, or inserted.

Calls add_residue() override that uses PSM_StubMode.

C++: protocols::cyclic_peptide::PeptideStubMover::add_residue(const std::string &, const std::string &, const unsigned long, const bool, const std::string &, const unsigned long, const unsigned long, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, const std::string &) –> void

add_residue(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideStubMover, stubmode: pyrosetta.rosetta.protocols.cyclic_peptide.PSM_StubMode, resname: str, position: int, jumpmode: bool, connecting_atom: str, repeat: int, anchor_rsd: int, anchor_rsd_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, anchor_atom: str) -> None

Adds a residue to the list of residues to be appended, prepended, or inserted.

This version uses enums.

Vikram K. Mulligan (vmullig.edu).

C++: protocols::cyclic_peptide::PeptideStubMover::add_residue(const enum protocols::cyclic_peptide::PSM_StubMode, const std::string &, const unsigned long, const bool, const std::string &, const unsigned long, const unsigned long, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, const std::string &) –> void

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

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

static assign_chain_ids(pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::cyclic_peptide::PeptideStubMover::assign_chain_ids(class core::pose::Pose &) –> void

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

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

clear_info is called by jd2 before calling apply

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

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

static default_label() → str¶: C++: protocols::cyclic_peptide::PeptideStubMover::default_label() –> std::string

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

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.cyclic_peptide.PeptideStubMover) → str¶: C++: protocols::cyclic_peptide::PeptideStubMover::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 > > &

init(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideStubMover) → None¶: C++: protocols::cyclic_peptide::PeptideStubMover::init() –> void

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::cyclic_peptide::PeptideStubMover::mover_name() –> std::string

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

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

provide_citation_info(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideStubMover, citations: pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::cyclic_peptide::PeptideStubMover::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_mover_data(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideStubMover) → None¶

Reset mover data

C++: protocols::cyclic_peptide::PeptideStubMover::reset_mover_data() –> void

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

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

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

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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_reset_mode(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideStubMover, reset_mode: bool) → None¶

Sets whether the pose gets reset (i.e. all residues deleted) or not.

C++: protocols::cyclic_peptide::PeptideStubMover::set_reset_mode(bool) –> void

set_residue_label(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideStubMover, label: str) → None¶

add label to residues that are created with this mover

Jack Maguire

C++: protocols::cyclic_peptide::PeptideStubMover::set_residue_label(const std::string &) –> 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

set_update_pdb_numbering_mode(self: pyrosetta.rosetta.protocols.cyclic_peptide.PeptideStubMover, mode: bool) → None¶

Sets whether pdb numbering gets updated or not.

C++: protocols::cyclic_peptide::PeptideStubMover::set_update_pdb_numbering_mode(bool) –> 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.cyclic_peptide.PeptideStubMoverCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector¶

Bases: ResidueSelector

Selects positions that would have a rama_prepro score below a given threshold IF mutated to a given residue type.

apply(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_bool¶

“Apply” function.

Given the pose, generate a vector of bools with entries for every residue in the pose indicating whether each residue is selected (“true”) or not (“false”).

C++: protocols::cyclic_peptide::RamaMutationSelector::apply(const class core::pose::Pose &) const –> class utility::vector1<bool, class std::allocator<bool> >

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

static class_name() → str¶

Get the mover class name.

C++: protocols::cyclic_peptide::RamaMutationSelector::class_name() –> std::string

clone(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶

Clone operator.

Copy the current object (creating the copy on the heap) and return an owning pointer to the copy. All ResidueSelectors must implement this.

C++: protocols::cyclic_peptide::RamaMutationSelector::clone() const –> class std::shared_ptr<class core::select::residue_selector::ResidueSelector>

get_name(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector) → str¶

Get the mover class name.

C++: protocols::cyclic_peptide::RamaMutationSelector::get_name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector, tag: pyrosetta.rosetta.utility.tag.Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

XML parse.

Parse RosettaScripts tags and set up this mover.

C++: protocols::cyclic_peptide::RamaMutationSelector::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : 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 residue selectors wishing to provide citation information.

C++: core::select::residue_selector::ResidueSelector::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶

Provide XSD information, enabling mechanical validation of input XML.

C++: protocols::cyclic_peptide::RamaMutationSelector::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

rama_prepro_multiplier(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector) → float¶

Get the weight multiplier of the rama_prepro term.

Defaults to 0.45 to match beta_nov15.

C++: protocols::cyclic_peptide::RamaMutationSelector::rama_prepro_multiplier() const –> const double &

score_threshold(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector) → float¶

Get the score threshold.

Positions which, when mutated to the target type, have a rama_prepro score above this threshold are not selected.

C++: protocols::cyclic_peptide::RamaMutationSelector::score_threshold() const –> const double &

selection_positions(self: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

Calls apply and returns the Rosetta numbering corresponding to the selected residues

C++: core::select::residue_selector::ResidueSelector::selection_positions(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

set_rama_prepro_multiplier(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector, multiplier_in: float) → None¶

Set the weight multiplier of the rama_prepro term.

Defaults to 0.45 to match beta_nov15.

C++: protocols::cyclic_peptide::RamaMutationSelector::set_rama_prepro_multiplier(const double &) –> void

set_score_threshold(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector, threshold_in: float) → None¶

Set the score threshold.

Positions which, when mutated to the target type, have a rama_prepro score above this threshold are not selected.

C++: protocols::cyclic_peptide::RamaMutationSelector::set_score_threshold(const double &) –> void

set_target_type(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector, type_in: str) → None¶

Set the residue type (full name) to which we are considering: mutations. If set to an empty string, selection is based on rama_prepro scoring of the residue type at each position.

C++: protocols::cyclic_peptide::RamaMutationSelector::set_target_type(const std::string &) –> void

target_type(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector) → str¶

Get the residue type (full name) to which we are considering: mutations. If set to an empty string, selection is based on rama_prepro scoring of the residue type at each position.

C++: protocols::cyclic_peptide::RamaMutationSelector::target_type() const –> const std::string &

class pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelectorCreator¶

Bases: ResidueSelectorCreator

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

create_residue_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelectorCreator) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector¶: C++: protocols::cyclic_peptide::RamaMutationSelectorCreator::create_residue_selector() const –> class std::shared_ptr<class core::select::residue_selector::ResidueSelector>

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign¶

Bases: Mover

Given a quasi-symmetric cyclic peptide, this mover aligns the peptide so that the cyclic symmetry axis lies along the Z-axis and the centre of mass is at the origin. It then optionally removes all but one symmetry repeat, so that true symmetry may be set up with the SetupForSymmetry mover.

angle_threshold(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → float¶

Get the angle threshold for counting poses as symmetric.

Two dihedral values from different residues must fall within this cutoff, in degrees, for them to be considered the “same”. Default 10 degrees.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::angle_threshold() const –> const double &

apply(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Apply the mover

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::apply(class core::pose::Pose &) –> void

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

auto_detect_symmetry(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → bool¶

Get whether we’re auto-detecting symmetry.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::auto_detect_symmetry() const –> bool

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

required in the context of the parser/scripting scheme

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::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.cyclic_peptide.SymmetricCycpepAlign) → pyrosetta.rosetta.protocols.moves.Mover¶

required in the context of the parser/scripting scheme

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::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¶

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.cyclic_peptide.SymmetricCycpepAlign) → str¶: C++: protocols::cyclic_peptide::SymmetricCycpepAlign::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 > > &

invert(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → bool¶

Are we aligning the peptide normal with the Z-axis (false) or the inverse Z-axis (true)?

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::invert() const –> bool

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

last_symmetry_mirror(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → bool¶

Report whether the symmetry of the last auto-detected peptide was mirror symmetry.

Returns false always if auto-detection is not enabled.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::last_symmetry_mirror() const –> bool

last_symmetry_repeats(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → int¶

Report the symmetry of the last auto-detected peptide.

Returns 0 if auto-detection is not enabled.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::last_symmetry_repeats() const –> unsigned long

mirror_symmetry(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → bool¶

Get whether we’re using mirror symmetry (e.g. s2 symmetry vs. c2 symmetry).

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::mirror_symmetry() const –> bool

static mover_name() → str¶: C++: protocols::cyclic_peptide::SymmetricCycpepAlign::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

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

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

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

Provide the citation.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::cyclic_peptide::SymmetricCycpepAlign::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

repeat_to_preserve(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → int¶

If trim_to_single_repeat_ is true, this is the symmetry repeat to preserve.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::repeat_to_preserve() const –> unsigned long

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_angle_threshold(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, setting: float) → None¶

Set the angle threshold for counting poses as symmetric.

Two dihedral values from different residues must fall within this cutoff, in degrees, for them to be considered the “same”. Default 10 degrees.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::set_angle_threshold(const double &) –> void

set_auto_detect_symmetry(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, setting: bool) → None¶

Set whether we’re auto-detecting symmetry.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::set_auto_detect_symmetry(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_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_invert(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, setting: bool) → None¶

Set whether we’re aligning the peptide normal with the Z-axis (false) or the inverse Z-axis (true).

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::set_invert(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_symmetry(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, repeats_in: int, mirror_in: bool) → None¶

Set the number of symmetry repeats and whether we’re using mirror symmetry. For example, for c4: symmetry, inputs are “4”, “false”. For s4, they’d be “4”, “true”.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::set_symmetry(const unsigned long, const bool) –> void

set_trim_info(*args, **kwargs)¶

Overloaded function.

set_trim_info(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, do_trim: bool) -> None
set_trim_info(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, do_trim: bool, repeat_to_preserve: int) -> None

Set whether we’re going to delete all geometry that isn’t the protein backbone of a single

symmetry repeat, and which repeat to preserve.

If set to true, the peptide will be trimmed down to a single repeat. False by default (no trimming).

If do_trim is set to true, this is the repeat that should be preserved. 1 by default.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::set_trim_info(const bool, const unsigned long) –> 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.cyclic_peptide.SymmetricCycpepAlign) -> None
show(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, output: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::show(std::ostream &) const –> void

symmetry_repeats(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → int¶

Get the number of symmetry repeats. For example, for c4 or s4 symmetry,: this would be “4”. Defaults to “2”.

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::symmetry_repeats() const –> unsigned long

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

: Unit test support function. Apply one move to a given pose.: Allows extra test specific functions to be called before applying

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

trim_to_single_repeat(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → bool¶

Get whether all geometry that is not the protein backbone of a single symmetry repeat will be: deleted. (This includes any crosslinkers.)

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::trim_to_single_repeat() const –> bool

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.cyclic_peptide.SymmetricCycpepAlignCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.TryDisulfPermutations¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.cyclic_peptide.TryDisulfPermutations, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Actually apply the mover to the pose.

C++: protocols::cyclic_peptide::TryDisulfPermutations::apply(class core::pose::Pose &) –> void

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

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.cyclic_peptide.TryDisulfPermutations) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::TryDisulfPermutations::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

consider_already_bonded(self: pyrosetta.rosetta.protocols.cyclic_peptide.TryDisulfPermutations) → bool¶

Will this mover consider alternative disulfides involving residues currently in a disulfide bond?

C++: protocols::cyclic_peptide::TryDisulfPermutations::consider_already_bonded() const –> bool

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.cyclic_peptide.TryDisulfPermutations) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::cyclic_peptide::TryDisulfPermutations::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¶

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.cyclic_peptide.TryDisulfPermutations) → str¶: C++: protocols::cyclic_peptide::TryDisulfPermutations::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

mintolerance(self: pyrosetta.rosetta.protocols.cyclic_peptide.TryDisulfPermutations) → float¶

Get the minimizer tolerance.

C++: protocols::cyclic_peptide::TryDisulfPermutations::mintolerance() const –> const double &

mintype(self: pyrosetta.rosetta.protocols.cyclic_peptide.TryDisulfPermutations) → str¶

Get the minmization flavour.

C++: protocols::cyclic_peptide::TryDisulfPermutations::mintype() const –> const std::string &

static mover_name() → str¶: C++: protocols::cyclic_peptide::TryDisulfPermutations::mover_name() –> std::string

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

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

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

Provide the citation.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::cyclic_peptide::TryDisulfPermutations::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_consider_already_bonded(self: pyrosetta.rosetta.protocols.cyclic_peptide.TryDisulfPermutations, setting: bool) → None¶

Set whether this mover will consider alternative disulfides involving residues currently in a disulfide bond.

C++: protocols::cyclic_peptide::TryDisulfPermutations::set_consider_already_bonded(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_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_mintolerance(self: pyrosetta.rosetta.protocols.cyclic_peptide.TryDisulfPermutations, val: float) → None¶

Set the minimizer tolerance.

C++: protocols::cyclic_peptide::TryDisulfPermutations::set_mintolerance(const double &) –> void

set_mintype(self: pyrosetta.rosetta.protocols.cyclic_peptide.TryDisulfPermutations, type: str) → None¶

Set the minimization flavour.

C++: protocols::cyclic_peptide::TryDisulfPermutations::set_mintype(const std::string &) –> 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_selector(self: pyrosetta.rosetta.protocols.cyclic_peptide.TryDisulfPermutations, selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set the residue selector.

CLONES the input.

C++: protocols::cyclic_peptide::TryDisulfPermutations::set_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> 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.cyclic_peptide.TryDisulfPermutationsCreator¶

Bases: MoverCreator

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

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

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

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

pyrosetta.rosetta.protocols.cyclic_peptide.cycpep_rigid_body_permutation_mover_mode_from_string(modestring: str) → pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMoverMode¶

Given a mover mode string, get the mode enum.

Returns CycpepRigidBodyPermutationMoverMode::UNKNOWN_MODE if string not recognized.

C++: protocols::cyclic_peptide::cycpep_rigid_body_permutation_mover_mode_from_string(const std::string &) –> enum protocols::cyclic_peptide::CycpepRigidBodyPermutationMoverMode

pyrosetta.rosetta.protocols.cyclic_peptide.list_cycpep_rigid_body_permutation_mover_modes() → str¶

Get a comma-separated list of valid mover modes.

C++: protocols::cyclic_peptide::list_cycpep_rigid_body_permutation_mover_modes() –> std::string

pyrosetta.rosetta.protocols.cyclic_peptide.string_from_cycpep_rigid_body_permutation_mover_mode(mode: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepRigidBodyPermutationMoverMode) → str¶

Given a mover mode enum, get the mode string.

C++: protocols::cyclic_peptide::string_from_cycpep_rigid_body_permutation_mover_mode(const enum protocols::cyclic_peptide::CycpepRigidBodyPermutationMoverMode) –> std::string