cyclic_peptide

• crosslinker

Bindings for protocols::cyclic_peptide namespace

class pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker

Bases: pybind11_builtins.pybind11_object

Enumeration of allowed crosslinkers.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(*args, **kwargs)

Overloaded function.

1. __eq__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker, arg0: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker) -> bool
2. __eq__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker, arg0: int) -> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getstate__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker) → tuple

__gt__

Return self>value.

__hash__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker) → int

__init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker, arg0: int) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__int__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker) → int

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(*args, **kwargs)

Overloaded function.

1. __ne__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker, arg0: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker) -> bool
2. __ne__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker, arg0: int) -> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker) → str

__setattr__

Implement setattr(self, name, value).

__setstate__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrossLinker, arg0: tuple) → None

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

class pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

This mover links three cysteine residues with a threefld-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), andthen optionally relaxes the whole structure.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) -> None
2. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover, arg0: pyrosetta.rosetta.protocols.cyclic_peptide.CrosslinkerMover) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

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

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_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 &

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.

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

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 class std::basic_string<char> &) –> enum protocols::cyclic_peptide::CrossLinker

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_std_allocator_std_string_t

non-const accessor

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

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

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

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

Get the linker name.

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

mover_name() → str

Returns the name of this Mover.

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

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

provide_xml_schema(xsd: pyrosetta.rosetta.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

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

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

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

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

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

set_filter_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 class std::basic_string<char> &) –> 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 class std::basic_string<char> &) –> void

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

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

show(*args, **kwargs)

Overloaded function.

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

C++: protocols::cyclic_peptide::CrosslinkerMover::show(class std::basic_ostream<char> &) 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.

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

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

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

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

class pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter, arg0: pyrosetta.rosetta.protocols.cyclic_peptide.CycpepSymmetryFilter) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

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

provide_xml_schema(xsd: pyrosetta.rosetta.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(class std::basic_ostream<char> &, 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 class std::basic_string<char> &) –> 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.OversaturatedHbondAcceptorFilter

Bases: pyrosetta.rosetta.protocols.filters.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) -> None
2. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter, arg0: pyrosetta.rosetta.protocols.cyclic_peptide.OversaturatedHbondAcceptorFilter) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

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

provide_xml_schema(xsd: pyrosetta.rosetta.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(class std::basic_ostream<char> &, 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 class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector

Bases: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector) -> None
2. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector, arg0: pyrosetta.rosetta.protocols.cyclic_peptide.RamaMutationSelector) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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 &

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_xml_schema(xsd: pyrosetta.rosetta.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 &

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 class std::basic_string<char> &) –> 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.SymmetricCycpepAlign

Bases: pyrosetta.rosetta.protocols.moves.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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) -> None
2. __init__(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, arg0: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

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

mover_name() → str

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

name() → str

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

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

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

register_options() → None

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

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

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

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

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

each use.

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

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

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

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

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

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

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

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

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

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

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

setter for poses contained for rms

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

set_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.

1. set_trim_info(self: pyrosetta.rosetta.protocols.cyclic_peptide.SymmetricCycpepAlign, do_trim: bool) -> None
2. 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

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

show(*args, **kwargs)

Overloaded function.

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

C++: protocols::cyclic_peptide::SymmetricCycpepAlign::show(class std::basic_ostream<char> &) 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.

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

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

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

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